Install Git and preview a safe commit identity

• Distinguish a missing executable from a missing repository.
• Verify Git's path and version rather than trusting an installer message.
• Explain command, repository and global identity scope.
• Preview GitTree Demo without changing an existing identity.

Finish lesson 1 first. You start with no course repository: nothing has been initialized yet. Use a terminal folder that is not a repository and GitTree's New Tab screen. Do not initialize anything before lesson 4.

The terminal commands were checked with Git 2.52.0 on macOS (/opt/homebrew/bin/git) and on Ubuntu 24.04 (/opt/git-2.52/bin/git). Your path and version can differ. GitTree's inspected requirement is Git 2.39.0 or newer; that floor is not a claim that 2.39.0 is today's latest or preferred security update. Choose a maintained package for your platform and verify it.

Native Git needs no sign-in. GitTree asks you to sign in with your email or a Git provider; the Free plan then covers every local Git feature, and your repositories stay on your computer. The recording predates that requirement, so the sign-in dialog is not shown. Author identity is not a GitTree account, provider credential or cryptographic signature. The GitTree steps were recorded in GitTree 2.0 on Ubuntu 24.04. On macOS, press Command where Windows and Linux use Ctrl.

A commit normally records both an author and a committer, each with a name and email. They can differ when someone applies another person's work. The ordinary starting case uses your configured identity for both. Writing a name does not prove that person owns an account; signing and hosting verification are separate subjects.

Think of identity configuration as choosing the return address on future records, not logging in to a server. Existing commits are not renamed when configuration changes. A pushed commit can expose its recorded email, so use an address you intend to make part of that history. All addresses in this course are fictional.

For ordinary scalar user.name and user.email, repository configuration overrides global defaults; explicit native -c overrides those config values for that invocation. GitTree's injected-profile implementation deliberately preserves a repository's own identity, as its UI explains. Do not treat that profile policy as identical to a manually typed -c. Environment variables, includes and worktree configuration can introduce additional inputs; advanced identity diagnosis comes in lesson 52. See Git's config reference and command-level options.

State boundary: inspecting a version/path or previewing -c values changes no working tree, index, local ref or remote ref. Installing Git changes software on the machine. Saving a profile/configuration would persist identity settings; we cancel the preview instead.

1. Inspect before installing

On macOS, on Windows in Git Bash, or on Linux:

command -v git
git --version

Observed authoring output, in command order:

/opt/homebrew/bin/git
git version 2.52.0

The path is this machine's result, not a required path to copy. In Windows PowerShell, use Get-Command git instead of command -v git, then run the same version query. Windows behavior has not been executed in this authoring check.

2. Install only when required

Skip this step if a usable maintained Git is already present. These commands are installation choices, not commands run while authoring this lesson. They change system software and may request approval.

• macOS: choose Xcode Command Line Tools, or Git through an already-installed Homebrew. Do not run both merely for this lesson. Official installation choices.

xcode-select --install

Alternative, only when Homebrew is already available:

brew install git

• Windows: obtain the installer for your architecture from the official Git for Windows installation page, finish its interactive setup, and open a fresh terminal. No specific installer-screen labels are assumed here.
• Linux: use your distribution's supported package channel. For Debian/Ubuntu, a common choice is below; Fedora uses sudo dnf install git. Inspect the resulting version: an older distribution may supply a package below GitTree's floor. Do not add a third-party package repository without reviewing its trust and maintenance implications. Official Linux choices.

sudo apt update
sudo apt install git

Installer/package-manager output varies by OS, package state and release; no fabricated transcript is supplied. After installation, open a fresh terminal, repeat the path/version queries and restart GitTree if necessary.

3. Preview, without saving

These native queries work without a repository. Each command carries both fictional fields explicitly.

git -c user.name="GitTree Demo" -c user.email=demo@example.com config --get user.name
git -c user.name="GitTree Demo" -c user.email=demo@example.com config --get user.email

Observed output, one line from each command:

GitTree Demo
demo@example.com

Now change only the command's email:

git -c user.name="GitTree Demo" -c user.email=maya@example.com config --get user.email

Observed output:

maya@example.com

That result belongs to this invocation. The earlier command would still return demo@example.com when run again. Neither command writes a configuration file or creates a commit. We do not print all of your existing Git configuration: it can contain private addresses or credential-bearing URLs.

Missing or unusable Git

If discovery fails, GitTree shows GitTree needs Git, This Git is too old or This Git could not be used. Looked in lists the paths it searched when Git is missing. Install or repair Git outside the app, then choose Check again: GitTree looks again and, only if it finds a usable Git, opens the regular New Tab. The video shows this on a machine where Git is hidden from the app alone: the missing-Git screen, then the same screen after Git is visible again, then New Tab.

Locate Git… also appears on that screen, but in the inspected source its action is empty, so do not rely on it as a working picker; use Check again after you fix the installation. You never need to uninstall a working Git to see this screen.

Preview identity with no repository

1. From New Tab, open Preferences (app.preferences.open): Command+, on macOS, Ctrl+, on Windows/Linux. Expect the full-window Preferences screen.
2. Choose Profiles in its navigation. Read the warning that Passed to each git command applies only to Git commands GitTree runs. If there are existing profiles, do not edit or switch them.
3. Choose New profile. Expect an unsaved form.
4. In Profile name, type Course preview. In Name for commits (user.name), type GitTree Demo. In Email for commits (user.email), type demo@example.com.
5. Leave Signing key (user.signingkey) and SSH command (core.sshCommand) empty. Under How the identity reaches git, inspect Passed to each git command. Do not select Written to ~/.gitconfig.
6. Choose Cancel, not Create profile. Expect the unsaved form to close without adding a profile. Choose Exit Preferences to return to New Tab.
7. Alternative route for later inspection: open Command Palette… with Command+Shift+P / Ctrl+Shift+P, type Switch Profile…, and select that exact command (profile.switch). It opens Profiles; it does not silently choose a different identity. Close via Exit Preferences without switching.

A separate Set up your Git identity dialog appears after an identity-related commit failure. It has Name, Email and explicit save targets. We do not force such a failure without a repository, and we do not use that dialog in this preview. Lesson 4 supplies the repository-local identity; lesson 52 teaches persisted profiles and configuration in depth.

At the end, you know the installed path/version and can predict the fictional command-scoped identity. There is still no course working tree, index, branch history, remote or graph. No global config or profile was saved.

• Installing GitTree and expecting bundled Git: the inspected setup flow uses your own Git installation.
• Using the account email as automatic Git identity: account and commit metadata are separate.
• Saving a fictional global identity: this can affect unrelated work; use the preview and the later course-repository-local setup.
• Assuming a profile changes external terminals: injected profiles apply to GitTree's commands, not arbitrary terminal processes.
• Expecting a name/email to authenticate a push: credentials and server permissions are separate.

If the version command cannot run, check installation and the terminal environment before investigating repository status. If Git runs but reports “not a git repository,” Git is present; initialization belongs in lesson 4.

If the shell and app disagree, restart the app after installation and choose Check again if the gate remains visible. Inspect the path/version in its diagnostic text when available. The source's inactive Locate callback is not a proven recovery path.

If you accidentally save or switch a profile, stop. Note which mechanism changed before restoring your prior, known configuration through its actual control. Do not delete arbitrary profiles or erase global config: those files can contain unrelated settings. GitTree's repository Undo journal is not a promised rollback for installation or identity configuration.

Answer each question, then read why. Questions marked “Required” count toward completing the lesson.

1. Question 1 of 6

   Question 1 of 6

   What does setting a commit name and email establish?

   Choose one answer.

   A signed commit

   Ownership of that provider account

   Metadata for future commits

   Check answer
2. Question 2 of 6

   Question 2 of 6

   Which actions do not persist a new identity?

   Choose every answer that applies.

   Fill New profile then Cancel

   Run git --version

   Run the lesson's git -c … config --get user.email

   Choose Create profile

   Check answer
3. Question 3 of 6

   Question 3 of 6Required

   After querying the supplied demo@example.com using -c, what changed?

   Choose one answer.

   Global email becomes demo@example.com

   The main ref now exists

   No persistent identity or Git state changed

   Check answer
4. Question 4 of 6

   Question 4 of 6Required

   Change the command's supplied email to maya@example.com. What does config --get user.email print?

   Choose one answer.

   maya@example.com

   A request to sign in

   demo@example.com

   Check answer
5. Question 5 of 6

   Question 5 of 6

   Git works in a fresh terminal, but the app still says GitTree needs Git. What next?

   Choose one answer.

   Reset the repository hard

   Assume Locate Git… is proven

   Restart/check discovery and compare its diagnostic path

   Check answer
6. Question 6 of 6

   Question 6 of 6Required

   run the original and changed email queries, preview the GitTree form and cancel. Which observations show the end state is unchanged?

   Choose every answer that applies.

   Outputs demo@example.com then maya@example.com

   No new profile row after Cancel

   A new graph commit

   Recorded usable Git path/version, with no global write

   Check answer

Predict the output when the preview email changes to maya@example.com, then run the changed-input query above and compare it. Repeat the original email query. Inspect the GitTree form, cancel it, and confirm no new profile row appears. Continue with no repository initialized.

• Verify the executable and version after installation; do not infer them.
• Commit identity is recorded metadata, not account authentication.
• Preview scope is temporary; repository, global and app-profile persistence differ.

• Distinguish Git, GitTree and your hosting provider (lesson 1)
• Download GitTree
• Git vs GitHub: what is the difference?

Author — مؤلف; committer — مُودِع; commit — إيداع; profile — ملف تعريف; repository — مستودع; command palette — لوحة الأوامر. Identity metadata is not a signature.