Version Control

Create project commits, review semantic history, restore safely, work with branches, publish qualified baselines, and optionally sync with GitHub.

Modeloop gives each project its own Git history, directly from the Project Hub. You can commit and restore locally without a GitHub account, then connect a remote repository when you want backup or collaboration.

Unlike a text diff, Modeloop reads model changes in engineering terms: blocks added or removed, parameters changed, connections rewired, and interfaces modified. Moving a block on the canvas is recorded as a cosmetic change, not presented as a change to the model’s behavior.

Save and commit are different. Saving preserves your current working project. A commit creates a named, reviewable point in its history. Commit whenever the project reaches a state you may want to compare, share, or restore.

Open Version Control

  1. Open a project and return to its Project Hub.
  2. Select Version Control in the project toolbar.

The Source control panel shows the project name, current branch, local or remote sync state, working changes, and commit history. Version control belongs to the whole project: one commit can capture coordinated changes across several models and project configuration files.

Each component card also carries a source-control status indicator. It tells you whether that model is committed, modified, or not yet versioned. The component history view highlights commits that affected that component without splitting it into a separate repository.

Create a commit

Working changes start unstaged, so you decide exactly what belongs in the next commit.

  1. In Changes, select the Stage control beside each model or project artifact you want to include. Use Stage all when the changes belong together.
  2. Select Review commit.
  3. If this is the first local commit and no author can be resolved, enter your name and email. This identity is stored for the project; local history does not require a hosting-account login.
  4. Review the staged files, semantic summary, cosmetic changes, effective author, and suggested commit message.
  5. Edit the message if needed, then select Commit changes.

Unstaged changes remain in your working copy and are not added to the commit. A commit still represents a complete, reproducible project state: Modeloop combines the staged changes with the unchanged content from the previous commit. The first commit captures the complete versioned project because no earlier state exists.

Use Unstage to remove an item from the next commit without changing the file. Use Discard changes only when you want that artifact to return to the current commit; Modeloop asks for confirmation first.

Write useful commit messages

Describe the engineering outcome, not the editing action:

  • Add overcurrent shutdown path
  • Tune speed-loop proportional gain
  • Split sensor acquisition into a 10 ms task

Messages such as changes or update model make later reviews and baselines harder to understand.

Read history and restore a version

Commit history lists the newest commits first, with author, date, message, and a semantic summary. A layout-only edit is reported as having no semantic model changes.

To restore an earlier state:

  1. Open the target commit in Commit history and select Restore.
  2. Choose Restore model to restore the selected model only, or Restore project to restore the complete project state.
  3. Confirm if the current project has uncommitted changes that would be replaced.

Restore does not delete or rewrite history. Modeloop applies the selected state and records the restoration as a new commit, so both the original work and the recovery remain traceable.

Work in branches

A branch is an independent line of project work. Use one when an experiment should not disturb main, or when a change needs review before integration.

  1. Expand Branches in the Source control panel.
  2. Enter a branch name and choose its Starting version. This can be the current version or an earlier commit.
  3. Select Create branch.
  4. Commit work normally on the branch.

The current branch is shown in the Project Hub header. From Branches, you can:

  • Switch between a branch and main;
  • Compare a branch with the commit where it began;
  • Merge its changes into the destination history;
  • Delete a branch after explicit confirmation.

Switching or merging never silently drops uncommitted work. If the working project is dirty, Modeloop stops and asks whether to discard those changes. Disjoint model changes merge automatically; semantic conflicts stop the merge and identify the affected models without modifying either history.

Publish a baseline

A baseline is more than a label on a commit. It is an immutable qualification record that binds a project version to the Modeloop tool version, generated-code digests, build configuration, and verification evidence.

Before publishing, make sure the selected version has a valid Build Configuration for the code target.

  1. Expand Baselines and select Publish baseline.
  2. Enter a unique baseline name and select the committed version.
  3. Choose the generated-code target: C or Python.
  4. Add one project-relative verification-evidence path or evidence ID per line.
  5. Select Verify artifacts. Modeloop regenerates the code and calculates its digests.
  6. When the artifacts are verified, select Publish immutable baseline.

A published baseline cannot be edited or deleted. To replace one, publish a new baseline and choose the previous record under Supersedes.

Back up and share with GitHub

Remote hosting is optional. Local commits, branches, comparisons, and restores continue to work without it.

To publish a local project:

  1. Expand Project repository and select Connect or publish repository. You can also select Share on GitHub from a local component-history view.
  2. Choose GitHub and select Connect GitHub.
  3. Copy the device code shown by Modeloop, open the displayed GitHub device page, and authorize the Modeloop GitHub App. Return to Modeloop; the flow continues automatically.
  4. Choose Use existing repository or Create new repository. Modeloop lists only repositories authorized for the connected account.
  5. If the project has no commit yet, set the commit author, review the first commit, and select Commit and push.

Connecting a GitHub account and choosing a repository are separate decisions. One connected account can be reused across projects, while every project remains bound to its own repository.

After a repository is connected, commits synchronize in the background. The Project Hub reports states such as Synced, commits pending, Offline, or Reconnect needed. Use Sync now when you want to retry immediately. A network or authentication failure never removes the local commit or blocks local work.

Remove Git remote disconnects the repository from this project but preserves local history and the connected hosting account. Disconnecting the hosting account from the app menu removes its stored credential; it does not delete the repository on GitHub.

Clone an existing Modeloop project

  1. On the Modeloop start screen, select Clone from GitHub.
  2. Connect or choose a GitHub account.
  3. Select an authorized repository containing Modeloop project history.
  4. Select Clone project.

The cloned project opens with its history and repository binding intact. If its commit identity differs from the connected account, Modeloop asks which email to use for future commits instead of silently changing authorship.

Safety rules to remember

  • History is project-wide, while component views filter or highlight the relevant commits.
  • Staging selects the content of the next commit; it does not modify your files.
  • Restore creates new history rather than erasing old history.
  • Branch operations stop before discarding uncommitted work.
  • Baselines are immutable and require reproducible generated artifacts.
  • Remote sync is optional; local work remains available when the network or provider is unavailable.