Installation

The fastest way to get Tulpar is the one-line installer — no compiler, no build tools, no admin rights. The script downloads the latest prebuilt release binary, drops it into a per-user location, and wires up your PATH.

One-line install (recommended)

Linux / macOS

curl -fsSL https://tulparlang.dev/install.sh | bash

tulpar is installed to ~/.local/bin/tulpar. If that directory is not already on your PATH, the installer prints the line to add to your shell rc (~/.bashrc, ~/.zshrc, or ~/.profile).

Windows (PowerShell)

iwr -useb https://tulparlang.dev/install.ps1 | iex

tulpar.exe is installed to %LOCALAPPDATA%\Programs\Tulpar\tulpar.exe and the directory is added to the user-level PATH. No administrator rights required. Open a new PowerShell or Command Prompt window after installation so the updated PATH takes effect.

Re-run the same command at any time to upgrade in place.

Verify the install

In a fresh terminal:

tulpar --version

You should see something like TulparLang v2.1.0.x (LLVM).

Windows GUI installer

Prefer a click-through experience with a Start Menu shortcut and an Add/Remove Programs entry? Download tulpar-setup-windows-x64.exe from the latest release. Per-user install, no admin rights needed.

Manual download

To pick a specific version, or download the binary by hand, grab an asset from the releases page:

Platform	Asset
Linux x86_64	`tulpar-linux-x64`
macOS (Intel + Apple Silicon)	`tulpar-macos-universal`
Windows x86_64 (portable binary)	`tulpar-windows-x64.exe`
Windows x86_64 (GUI installer)	`tulpar-setup-windows-x64.exe`

On Linux and macOS, mark the binary as executable and place it on your PATH:

chmod +x tulpar-linux-x64
mv tulpar-linux-x64 ~/.local/bin/tulpar

Updating

tulpar update

Self-updates the installed binary from the latest release. Re-running the install one-liner has the same effect.

Uninstalling

Linux / macOS: rm ~/.local/bin/tulpar and (optionally) remove the PATH export line from your shell rc.
Windows (one-liner install): delete the %LOCALAPPDATA%\Programs\Tulpar\ folder and remove the entry from the User PATH via System Properties → Environment Variables.
Windows (GUI install): uninstall from Settings → Apps.

Build from source

You only need this if you are hacking on the compiler, building for a platform we don’t ship a binary for, or want a debug build. Most users should use the one-liner installer above.

Prerequisites: GCC or Clang (C++17), LLVM 18 or newer (18 through 22 are tested), and CMake 3.14+. The build needs LLVM’s development tree — headers plus the static libs (LLVMCore, LLVMSupport, …) — not just the clang compiler.

Install the toolchain

Ubuntu / Debian:

sudo apt install build-essential cmake llvm-18-dev
# sanity check: should print 18.x
llvm-config-18 --version

Fedora:

sudo dnf install gcc-c++ cmake llvm-devel

Arch Linux:

sudo pacman -S base-devel cmake llvm

macOS (Homebrew):

brew install llvm@18 cmake

Homebrew’s LLVM is keg-only, so CMake won’t find it automatically. Point it at the cellar before building:

export LLVM_DIR="$(brew --prefix llvm@18)/lib/cmake/llvm"
export PATH="$(brew --prefix llvm@18)/bin:$PATH"

Windows: the official LLVM installer and Chocolatey ship only the clang compiler — not the static dev libs Tulpar links against. The reliable route is MSYS2 (mingw64):

pacman -S mingw-w64-x86_64-gcc mingw-w64-x86_64-cmake \
          mingw-w64-x86_64-llvm mingw-w64-x86_64-zlib \
          mingw-w64-x86_64-zstd mingw-w64-x86_64-libxml2

Clone and build

git clone https://github.com/hamer1818/TulparLang.git
cd TulparLang

Linux / macOS:

./build.sh

Windows:

.\build.ps1

build.bat / build.ps1 auto-detect the toolchain: MSVC + a Windows LLVM dev tree (C:\Program Files\LLVM) if present, otherwise an MSYS2 mingw64 install (C:\msys64).

The result is a tulpar (tulpar.exe on Windows) executable copied to the repository root, plus libtulpar_runtime.a (.lib on Windows) which AOT-compiled user binaries link against.

build.sh and build.ps1 wipe the build directory on every run. For incremental rebuilds during development, drive CMake directly:

cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build -j