Pkg.jl

https://pkgdocs.julialang.org/v1/
Admin
Pkg.jl is Julia's package manager that manages project-specific environments, dependencies, and...
Tokens:95,237
Snippets:693
Trust Score:10
Update:6 days ago
Show doc for...
Tokens:
Raw
### Pkg.Registry.add Examples

Source: https://pkgdocs.julialang.org/v1/api

Examples of adding registries by name, UUID, and URL. The no-argument form installs default registries.

```julia
Pkg.Registry.add("General")
Pkg.Registry.add(uuid = "23338594-aafe-5451-b93e-139f81909106")
Pkg.Registry.add(url = "https://github.com/JuliaRegistries/General.git")
```

--------------------------------

### Pkg.Apps.develop examples

Source: https://pkgdocs.julialang.org/v1/apps

Examples of developing an app from a registry name and a local path.

```julia
Pkg.Apps.develop("Runic")
Pkg.Apps.develop(path = "path/to/Package")
```

--------------------------------

### Pkg.Apps.add examples

Source: https://pkgdocs.julialang.org/v1/apps

Examples of adding apps from a registry, a specific version, a git URL with a revision, and a local path.

```julia
Pkg.Apps.add("Runic")
Pkg.Apps.add(name = "Runic", version = "1.5")
Pkg.Apps.add(url = "https://github.com/fredrikekre/Runic.jl", rev = "master")
Pkg.Apps.add(path = "path/to/Package")
```

--------------------------------

### [compat] section example with [deps]

Source: https://pkgdocs.julialang.org/v1/toml-files

Shows a dependency Example with a compatibility constraint of version 1.2.

```toml
[deps]
Example = "7876af07-990d-54b4-ab0e-23690620f79a"

[compat]
Example = "1.2"
```

--------------------------------

### registry status example

Source: https://pkgdocs.julialang.org/v1/repl

Example of using `registry status` to display installed registries.

```julia
pkg> registry status
```

--------------------------------

### Load installed package in Julia

Source: https://pkgdocs.julialang.org/v1/getting-started

After installation, the package can be loaded with `import Example` and used, as shown by calling `Example.hello("friend")`.

```julia
julia> import Example

julia> Example.hello("friend")
"Hello, friend"
```

--------------------------------

### Compat.toml version blocks example

Source: https://pkgdocs.julialang.org/v1/registries

Example of a Compat.toml file with version blocks. Dependencies unchanged across a range of versions are grouped together. The ranges are interpreted as described in the following comment example.

```toml
["0.8-0.8.3"]
DependencyA = "0.4-0.5"
DependencyB = "0.3-0.5"

["0.8.2-0.8.5"]
DependencyC = "0.7-0"

```

--------------------------------

### Pkg.precompile usage examples

Source: https://pkgdocs.julialang.org/v1/api

Examples of calling Pkg.precompile with no arguments, a single package, and a list of packages.

```julia
Pkg.precompile()
Pkg.precompile("Foo")
Pkg.precompile(["Foo", "Bar"])
```

--------------------------------

### Pkg.setprotocol! usage examples

Source: https://pkgdocs.julialang.org/v1/api

Examples showing how to set the protocol for GitHub and custom domains, including using SSH, HTTPS, Git, and resetting to default.

```julia
julia> Pkg.setprotocol!(domain = "github.com", protocol = "ssh")

# Use HTTPS for GitHub (default, good for most users)
julia> Pkg.setprotocol!(domain = "github.com", protocol = "https")

# Reset to default (let package developer decide)
julia> Pkg.setprotocol!(domain = "github.com", protocol = nothing)

# Set protocol for custom domain without specifying protocol
julia> Pkg.setprotocol!(domain = "gitlab.mycompany.com")

# Use Git protocol for a custom domain
julia> Pkg.setprotocol!(domain = "gitlab.mycompany.com", protocol = "git")
```

--------------------------------

### Example [compat] entry in Project.toml

Source: https://pkgdocs.julialang.org/v1/compatibility

Shows the format for specifying compatibility for the julia version and a dependency named Example. After adding such entries, use the `up` command to apply them.

```toml
[compat]
julia = "1.6"
Example = "0.5"

```

--------------------------------

### Project.toml with multiple packages of the same name

Source: https://pkgdocs.julialang.org/v1/toml-files

Shows a `Project.toml` file where two packages `A` and `B` are added, with `A` depending on a different `B` package (different UUID). This is the setup for the subsequent `Manifest.toml` example.

```toml
[deps]
A = "ead4f63c-334e-11e9-00e6-e7f0a5f21b60"
B = "edca9bc6-334e-11e9-3554-9595dbb4349c"

```

--------------------------------

### Pkg.develop examples

Source: https://pkgdocs.julialang.org/v1/api

Shows how to develop a package by name, URL, or local path.

```julia
# By name
Pkg.develop("Example")

# By url
Pkg.develop(url="https://github.com/JuliaLang/Compat.jl")

# By path
Pkg.develop(path="MyJuliaPackages/Package.jl")
```

--------------------------------

### pin REPL command examples

Source: https://pkgdocs.julialang.org/v1/repl

Examples of using the `pin` command with a package name, a version, a UUID with version, and the `--all` option.

```julia
pkg> pin Example
pkg> pin Example@0.5.0
pkg> pin Example=7876af07-990d-54b4-ab0e-23690620f79a@0.5.0
pkg> pin --all
```

--------------------------------

### Pkg.free usage examples

Source: https://pkgdocs.julialang.org/v1/api

Examples of freeing a single package, multiple packages, or all packages in the project.

```julia
# Free a single package (remove pin or stop tracking path)
Pkg.free("Package")

# Free multiple packages
Pkg.free(["PackageA", "PackageB"])

# Free all packages in the project
Pkg.free(all_pkgs = true)
```

--------------------------------

### Pkg.readonly usage examples

Source: https://pkgdocs.julialang.org/v1/api

Examples showing how to check and set the readonly state, including the returned previous state.

```julia
julia> Pkg.readonly()  # check current readonly state
false

julia> Pkg.readonly(true)  # enable readonly mode
false  # returns previous state

julia> Pkg.readonly()
true

julia> Pkg.readonly(false)  # disable readonly mode
true
```

--------------------------------

### Pkg.pin usage examples

Source: https://pkgdocs.julialang.org/v1/api

Examples of pinning a package to its current version, to a specific version, or pinning all packages in the project.

```julia
# Pin a package to its current version
Pkg.pin("Example")

# Pin a package to a specific version
Pkg.pin(name="Example", version="0.3.1")

# Pin all packages in the project
Pkg.pin(all_pkgs = true)
```

--------------------------------

### Trigger precompilation via `using Example`

Source: https://pkgdocs.julialang.org/v1/environments

Shows the output when importing a package triggers precompilation. The `[ Info: Precompiling Example [7876af07-990d-54b4-ab0e-23690620f79a]` message indicates the package is being precompiled.

```julia
julia> using Example
[ Info: Precompiling Example [7876af07-990d-54b4-ab0e-23690620f79a]
```

--------------------------------

### Pkg REPL `add` command examples

Source: https://pkgdocs.julialang.org/v1/repl

Examples of using the `add` command in the Pkg REPL, covering version, branch, commit, URL, SSH, and UUID specifications.

```julia
pkg> add Example
pkg> add --preserve=all Example
pkg> add --weak Example
pkg> add --extra Example
pkg> add Example@0.5
pkg> add Example#master
pkg> add Example#c37b675
pkg> add https://github.com/JuliaLang/Example.jl#master
pkg> add git@github.com:JuliaLang/Example.jl.git
pkg> add "git@github.com:JuliaLang/Example.jl.git"#master
pkg> add https://github.com/Company/MonoRepo:juliapkgs/Package.jl
pkg> add Example=7876af07-990d-54b4-ab0e-23690620f79a
```

--------------------------------

### develop REPL command examples

Source: https://pkgdocs.julialang.org/v1/repl

Examples of using the `develop` command with a registered package, a git URL, a local path, and the `--local` option.

```julia
pkg> develop Example
pkg> develop https://github.com/JuliaLang/Example.jl
pkg> develop ~/mypackages/Example
pkg> develop --local Example
```

--------------------------------

### Pkg.Registry.update Examples

Source: https://pkgdocs.julialang.org/v1/api

Examples of updating all registries, updating a specific registry by name, and updating by UUID.

```julia
Pkg.Registry.update()
Pkg.Registry.update("General")
Pkg.Registry.update(uuid = "23338594-aafe-5451-b93e-139f81909106")
```

--------------------------------

### Install shared packages interactively or from Project.toml

Source: https://pkgdocs.julialang.org/v1/depots

Install commonly-used packages either interactively with Pkg.add or by instantiating from a Project.toml file. The Project.toml approach is recommended for reproducibility.

```bash
# Interactive installation
julia -e 'using Pkg; Pkg.add(["Plots", "DataFrames", "CSV", "LinearAlgebra"])'

# Or from a Project.toml file
cd /opt/julia/shared_depot
# Create or copy your Project.toml and Manifest.toml files here
julia --project=. -e 'using Pkg; Pkg.instantiate()'
```

--------------------------------

### Pkg.instantiate

Source: https://pkgdocs.julialang.org/v1/api

Instantiates the active project by downloading and installing all packages declared in the Manifest.toml, or resolving and installing from Project.toml if no manifest exists. Supports verbose output, workspace instantiation, and strict Julia version checking.

```APIDOC
## Pkg.instantiate

### Description
If a `Manifest.toml` file exists in the active project, download all the packages declared in that manifest. Otherwise, resolve a set of feasible packages from the `Project.toml` files and install them. After packages have been installed the project will be precompiled.

### Function Signature
```julia
Pkg.instantiate(; verbose = false, workspace=false, io::IO=stderr, julia_version_strict=false)
```

### Parameters
#### Keyword Arguments
- **verbose** (Bool) - Optional - If `true`, prints the build output to `stdout`/`stderr` instead of redirecting to the `build.log` file.
- **workspace** (Bool) - Optional - If `true`, also instantiate all projects in the workspace.
- **io** (IO) - Optional - The I/O stream to which output is written. Defaults to `stderr`.
- **julia_version_strict** (Bool) - Optional - If `true`, turn manifest version check failures into errors instead of logging warnings. Requires at least Julia 1.12.

### Notes
- If no `Project.toml` exists in the current active project, one is created with all the dependencies in the manifest and the resulting project is instantiated.
- The `julia_version_strict` keyword argument requires at least Julia 1.12.
```

--------------------------------

### Pkg.autoprecompilation_enabled usage example

Source: https://pkgdocs.julialang.org/v1/api

Example of disabling and re-enabling automatic precompilation. When disabled, Pkg.add does not trigger auto-precompilation; when enabled, it does.

```julia
# Disable automatic precompilation
Pkg.autoprecompilation_enabled(false)
Pkg.add("Example")  # Will not trigger auto-precompilation
Pkg.precompile()    # Manual precompilation

# Re-enable automatic precompilation
Pkg.autoprecompilation_enabled(true)
Pkg.add("AnotherPackage")  # Will trigger auto-precompilation
```

--------------------------------

### Pkg.status outdated example output

Source: https://pkgdocs.julialang.org/v1/api

Example output from Pkg.status with outdated=true, showing packages with available updates and compatibility constraints.

```julia
julia> Pkg.status(; outdated=true)
Status `Manifest.toml`
⌃ [a8cc5b0e] Crayons v2.0.0 [<v3.0.0], (<v4.0.4)
⌅ [b8a86587] NearestNeighbors v0.4.8 (<v0.4.9) [compat]
⌅ [2ab3a3ac] LogExpFunctions v0.2.5 (<v0.3.0): SpecialFunctions
```

--------------------------------

### registry add examples

Source: https://pkgdocs.julialang.org/v1/repl

Examples of using `registry add` to add the General registry, a custom registry URL, and to add known registries with no arguments.

```julia
pkg> registry add General
pkg> registry add https://www.my-custom-registry.com
pkg> registry add
```

--------------------------------

### Install Julia apps with pkg> app add

Source: https://pkgdocs.julialang.org/v1/apps

Install apps from a registry, a git URL, or a local path. The local path must be a git repository. Comments show usage for registry, specific version, git URL, and local path.

```julia
pkg> app add Runic          # from a registry
pkg> app add Runic@1.5      # specific version
pkg> app add https://github.com/fredrikekre/Runic.jl
pkg> app add path/to/Package  # local path (must be a git repository)
```

--------------------------------

### dev a registered package

Source: https://pkgdocs.julialang.org/v1/managing-packages

Run `dev Example` in the Julia Pkg REPL to clone the registered package `Example` to `~/.julia/dev/` and track the path. The output shows the git clone and the update to the project and manifest files.

```julia-repl
(@v1.10) pkg> dev Example
  Updating git-repo `https://github.com/JuliaLang/Example.jl.git`
   Resolving package versions...
    Updating `~/.julia/environments/v1.10/Project.toml`
  [7876af07] + Example v0.5.4 `~/.julia/dev/Example`
    Updating `~/.julia/environments/v1.8/Manifest.toml`
  [7876af07] + Example v0.5.4 `~/.julia/dev/Example`

```

--------------------------------

### Pkg.Apps.add

Source: https://pkgdocs.julialang.org/v1/apps

Install apps from a package into an isolated environment and create shims in ~/.julia/bin.

```APIDOC
## Pkg.Apps.add

### Description
Install the apps of package `pkg`. The package is installed into an isolated environment and shims for its apps are created in `~/.julia/bin` (which should be added to `PATH`). Apps can be added from a registry, a git URL, or a local path (which needs to be a git repository).

### Method
Function call

### Endpoint
`Pkg.Apps.add(pkg::Union{String, PackageSpec})`
`Pkg.Apps.add(; name, uuid, version, url, rev, path, subdir)`

### Parameters
- `pkg` (Union{String, PackageSpec}) - Required - The package to install apps from.
- `name` (String) - Optional - Package name.
- `uuid` (UUID) - Optional - Package UUID.
- `version` (VersionNumber) - Optional - Package version.
- `url` (String) - Optional - Git URL of the package.
- `rev` (String) - Optional - Git revision.
- `path` (String) - Optional - Local path to the package (must be a git repository).
- `subdir` (String) - Optional - Subdirectory within the package.

### Request Example
```julia
Pkg.Apps.add("Runic")
Pkg.Apps.add(name = "Runic", version = "1.5")
Pkg.Apps.add(url = "https://github.com/fredrikekre/Runic.jl", rev = "master")
Pkg.Apps.add(path = "path/to/Package")
```

### Response
No return value documented.
```

--------------------------------

### Add a package with Pkg REPL `add`

Source: https://pkgdocs.julialang.org/v1/getting-started

Adds the Example package and shows the expected output, including version resolution and updates to Project.toml and Manifest.toml.

```text
(@v1.10) pkg> add Example
   Resolving package versions...
   Installed Example ─ v0.5.3
    Updating `~/.julia/environments/v1.10/Project.toml`
  [7876af07] + Example v0.5.3
    Updating `~/.julia/environments/v1.10/Manifest.toml`
  [7876af07] + Example v0.5.3
```

--------------------------------

### Pkg.build

Source: https://pkgdocs.julialang.org/v1/api

Runs the build script in `deps/build.jl` for a package and all its dependencies in depth-first recursive order. Called automatically on any package that gets installed for the first time.

```APIDOC
## Pkg.build

### Description
Run the build script in `deps/build.jl` for `pkg` and all of its dependencies in depth-first recursive order. If no argument is given, the current project is built, which thus needs to be a package.

### Method
Function

### Signature
`Pkg.build(; verbose = false, io::IO=stderr)`
`Pkg.build(pkg::Union{String, Vector{String}}; verbose = false, io::IO=stderr)`
`Pkg.build(pkgs::Union{PackageSpec, Vector{PackageSpec}}; verbose = false, io::IO=stderr)`

### Parameters
#### Keyword Arguments
- **verbose** (Bool) - Optional - Print the build output to `stdout`/`stderr` instead of redirecting to the `build.log` file.
- **allow_reresolve** (Bool) - Optional - Allow Pkg to reresolve the package versions in the build environment. Requires at least Julia 1.13.
- **io** (IO) - Optional - Output stream for build output.

### Request Example
```julia
Pkg.build()
Pkg.build("Example")
```

### Response
#### Success Response
No return value. The build takes place in a new process matching the current process with default of `startup-file=no`.

```

--------------------------------

### Free a package to return to registry version (free Example)

Source: https://pkgdocs.julialang.org/v1/managing-packages

Reverts a package from tracking a branch/commit back to the registry version. The output shows the installed version and the change in Project.toml and Manifest.toml.

```julia-repl
(@v1.10) pkg> free Example
   Resolving package versions...
   Installed Example ─ v0.5.3
    Updating `~/.julia/environments/v1.10/Project.toml`
  [7876af07] ~ Example v0.5.4 `https://github.com/JuliaLang/Example.jl.git#master` ⇒ v0.5.3
    Updating `~/.julia/environments/v1.10/Manifest.toml`
  [7876af07] ~ Example v0.5.4 `https://github.com/JuliaLang/Example.jl.git#master` ⇒ v0.5.3
```

--------------------------------

### Pre-seed user environments with template project

Source: https://pkgdocs.julialang.org/v1/depots

As administrator, create a template project with desired packages, then users copy the template and run Pkg.instantiate(). Packages already in the shared depot are found automatically, so instantiate() only downloads missing packages.

```bash
# As administrator, create template
mkdir -p /opt/julia/template_project
# Create Project.toml with desired packages
julia --project=/opt/julia/template_project -e 'using Pkg; Pkg.add("Example"); Pkg.add("Plots")'

# Users copy the template and instantiate
cp -r /opt/julia/template_project ~/my_project
cd ~/my_project
julia --project=. -e 'using Pkg; Pkg.instantiate()'
```

--------------------------------

### [registries.General] entry in Manifest.toml

Source: https://pkgdocs.julialang.org/v1/toml-files

Example of a registry entry in the [registries] section of a manifest with format 2.1. The uuid is required and the url enables automatic registry installation when instantiating an environment on a new machine.

```toml
[registries.General]
uuid = "23338594-aafe-5451-b93e-139f81909106"
url = "https://github.com/JuliaRegistries/General.git"
```

--------------------------------

### Enter the project directory

Source: https://pkgdocs.julialang.org/v1/creating-packages

Change the current directory to the project directory for the rest of the tutorial.

```julia
julia> cd("HelloWorld")
```

--------------------------------

### Pkg.Registry.rm Examples

Source: https://pkgdocs.julialang.org/v1/api

Examples of removing registries by name and by UUID.

```julia
Pkg.Registry.rm("General")
Pkg.Registry.rm(uuid = "23338594-aafe-5451-b93e-139f81909106")
```

--------------------------------

### Add a package and inspect environment files

Source: https://pkgdocs.julialang.org/v1/environments

Shows adding the Example package to the new environment, then reading the directory and printing the generated Project.toml and Manifest.toml. The Manifest.toml is machine-generated and should not be edited directly.

```julia-repl
julia> isdir("MyProject")
false

(MyProject) pkg> add Example
   Resolving package versions...
   Installed Example ─ v0.5.3
    Updating `~/MyProject/Project.toml`
  [7876af07] + Example v0.5.3
    Updating `~/MyProject/Manifest.toml`
  [7876af07] + Example v0.5.3
Precompiling environment...
  1 dependency successfully precompiled in 2 seconds

julia> readdir("MyProject")
2-element Vector{String}:
 "Manifest.toml"
 "Project.toml"

julia> print(read(joinpath("MyProject", "Project.toml"), String))
[deps]
Example = "7876af07-990d-54b4-ab0e-23690620f79a"

julia> print(read(joinpath("MyProject", "Manifest.toml"), String))
# This file is machine-generated - editing it directly is not advised

julia_version = "1.10.0"
manifest_format = "2.0"
project_hash = "2ca1c6c58cb30e79e021fb54e5626c96d05d5fdc"

[[deps.Example]]
git-tree-sha1 = "46e44e869b4d90b96bd8ed1fdcf32244fddfb6cc"
uuid = "7876af07-990d-54b4-ab0e-23690620f79a"
version = "0.5.3"
```

--------------------------------

### Pkg.add examples

Source: https://pkgdocs.julialang.org/v1/api

Shows various ways to call Pkg.add: adding from registry, specifying target, preserving dependencies, specifying version, and using URL/path sources.

```julia
Pkg.add("Example") # Add a package from registry
Pkg.add("Example", target=:weakdeps) # Add a package as a weak dependency
Pkg.add("Example", target=:extras) # Add a package to the `[extras]` list
Pkg.add("Example"; preserve=Pkg.PRESERVE_ALL) # Add the `Example` package and strictly preserve existing dependencies
Pkg.add(name="Example", version="0.3") # Specify version; latest release in the 0.3 series
Pkg.add(name="Example", version="0.3.1") # Specify version; exact release
Pkg.add(url="https://github.com/JuliaLang/Example.jl", rev="master") # From url to remote gitrepo
Pkg.add(url="/remote/mycompany/juliapackages/OurPackage") # From path to local gitrepo
Pkg.add(url="https://github.com/Company/MonoRepo", subdir="juliapkgs/Package.jl") # With subdir
```

--------------------------------

### registry remove example

Source: https://pkgdocs.julialang.org/v1/repl

Example of using `registry remove` to remove the General registry.

```julia
pkg> registry [rm|remove] General
```

--------------------------------

### instantiate command syntax

Source: https://pkgdocs.julialang.org/v1/repl

Syntax for the `instantiate` REPL command. Downloads dependencies for the current project.

```julia
instantiate [-v|--verbose] [--workspace] [--julia_version_strict]
instantiate [-v|--verbose] [--workspace] [--julia_version_strict] [-m|--manifest]
instantiate [-v|--verbose] [--workspace] [--julia_version_strict] [-p|--project]
```

--------------------------------

### Pkg.activate() examples: default, path, package, temp

Source: https://pkgdocs.julialang.org/v1/api

Shows four ways to call Pkg.activate: with no arguments to return to the default environment, with a path, with a developed package name, and with the temp keyword to create a temporary environment.

```julia
# Return to default environment (deactivate current project)
Pkg.activate()

# Activate a project in a specific directory
Pkg.activate("local/path")

# Activate a developed package by name
Pkg.activate("MyDependency")

# Create and activate a temporary environment
Pkg.activate(; temp=true)
```

--------------------------------

### registry update examples

Source: https://pkgdocs.julialang.org/v1/repl

Examples of using `registry update` to update all registries and to update the General registry.

```julia
pkg> registry up
pkg> registry up General
```

--------------------------------

### uuid field example

Source: https://pkgdocs.julialang.org/v1/toml-files

Example of the uuid field in Project.toml, which is a string with a universally unique identifier and is mandatory for packages.

```TOML
uuid = "7876af07-990d-54b4-ab0e-23690620f79a"
```

--------------------------------

### Activate and load the generated package

Source: https://pkgdocs.julialang.org/v1/creating-packages

Activate the project by its path, then import the package and call the greet function to see the output.

```julia
pkg> activate ./HelloWorld

julia> import HelloWorld

julia> HelloWorld.greet()
Hello World!
```

--------------------------------

### Pkg.precompile do-block example

Source: https://pkgdocs.julialang.org/v1/api

Shows how to delay autoprecompilation of multiple Pkg actions until the end using the do-block syntax. Requires Julia 1.13.

```julia
Pkg.precompile() do
    # Pkg actions here
end
```

--------------------------------

### name field example

Source: https://pkgdocs.julialang.org/v1/toml-files

Example of the name field in Project.toml. The name must be a valid identifier and is mandatory for packages.

```TOML
name = "Example"
```

--------------------------------

### Ask Pkg for help

Source: https://pkgdocs.julialang.org/v1/getting-started

Run the help command in the Pkg REPL to see a list of available commands with short descriptions.

```julia-repl
(@v1.10) pkg> ?
```

--------------------------------

### ensure_artifact_installed function signature

Source: https://pkgdocs.julialang.org/v1/api

Signature for ensuring an artifact is installed, downloading if necessary. Throws an error if unable to install.

```julia
ensure_artifact_installed(name::String, artifacts_toml::String;
                            platform::AbstractPlatform = HostPlatform(),
                            pkg_uuid::Union{Base.UUID,Nothing}=nothing,
                            verbose::Bool = false,
                            quiet_download::Bool = false,
                            io::IO=stderr)
```

--------------------------------

### Show installed packages with `status`

Source: https://pkgdocs.julialang.org/v1/getting-started

Displays the status of installed packages in the current environment, showing versions and UUIDs.

```text
(@v1.10) pkg> st
Status `~/.julia/environments/v1.10/Project.toml`
  [7876af07] Example v0.5.3
  [682c06a0] JSON v0.21.3
  [90137ffa] StaticArrays v1.5.9
```

--------------------------------

### Inequality specifier examples

Source: https://pkgdocs.julialang.org/v1/compatibility

Examples of inequality specifiers (>=, ≥, <) to define version ranges. The ≥ symbol is accepted as an alternative to >=.

```TOML
[compat]
PkgB = ">= 1.2.3" # [1.2.3,  ∞)
PkgC = "≥ 1.2.3"  # [1.2.3,  ∞)
PkgD = "< 1.2.3"  # [0.0.0, 1.2.3) = [0.0.0, 1.2.2]

```

--------------------------------

### version field example

Source: https://pkgdocs.julialang.org/v1/toml-files

Example of the version field in Project.toml, which should consist of three numbers separated by dots and follow Semantic Versioning.

```TOML
version = "1.2.5"
```

--------------------------------

### Run Julia script with --project flag

Source: https://pkgdocs.julialang.org/v1/environments

Shows how to specify a project on startup using the --project flag, running a script from the current directory.

```shell
$ julia --project=. myscript.jl
```

--------------------------------

### Get detailed help for a specific command

Source: https://pkgdocs.julialang.org/v1/getting-started

Use the help command with a command name, such as develop, to get more detailed information about that command.

```julia-repl
(@v1.10) pkg> ?develop
```

--------------------------------

### Caret specifier examples

Source: https://pkgdocs.julialang.org/v1/compatibility

Examples of caret (^) specifiers and their resulting version bounds. The caret allows upgrades that do not modify the left-most non-zero digit.

```TOML
[compat]
PkgA = "^1.2.3" # [1.2.3, 2.0.0)
PkgB = "^1.2"   # [1.2.0, 2.0.0)
PkgC = "^1"     # [1.0.0, 2.0.0)
PkgD = "^0.2.3" # [0.2.3, 0.3.0)
PkgE = "^0.0.3" # [0.0.3, 0.0.4)
PkgF = "^0.0"   # [0.0.0, 0.1.0)
PkgG = "^0"     # [0.0.0, 1.0.0)

```

--------------------------------

### Clone, activate, and instantiate a Julia project

Source: https://pkgdocs.julialang.org/v1/environments

Shows the shell commands to clone a project, activate its environment, and instantiate it. The output shows the expected messages when no packages need to be added or removed.

```shell
shell> git clone https://github.com/JuliaLang/Example.jl.git
Cloning into 'Example.jl'...
...

(@v1.10) pkg> activate Example.jl
Activating project at `~/Example.jl`

(Example) pkg> instantiate
  No packages added to or removed from `~/Example.jl/Project.toml`
  No packages added to or removed from `~/Example.jl/Manifest.toml`
```
Tokens:
Raw