Setup and updates

Installation

Set up the Livt development environment using Visual Studio Code, or install the toolchain manually for command-line development and automation.

Livt provides an integrated toolchain for developing FPGA applications, including language services, compilation, testing, and hardware generation. The recommended installation uses the Livt extension for Visual Studio Code, which manages compatible tools and their configuration through guided setup.

For terminal-only environments, continuous integration (CI), or custom toolchains, Livt also supports manual installation on Linux and Windows.

Choose an installation method

Method	Recommended for	Installation and maintenance
Visual Studio Code	Interactive development and most local environments	Guided installation, compatible tools, licence management, optional simulation, and updates
Manual installation	CI runners, automation, terminal-only environments, and custom toolchains	Direct control over installed tools, versions, paths, and updates

Install with Visual Studio Code

The Livt extension adds language support, project management, build and test commands, and Livt Agent to VS Code. Its Get Started with Livt walkthrough guides you through initial setup, then introduces the development workflow. Follow its setup steps below; the installation manager remains available afterwards for updates and licence management.

Install the Livt extension

Open the Extensions view in VS Code and search for Livt. Select the extension published by Eccelerators and choose Install. Check the publisher before installing, because similarly named extensions may appear in the results.

VS Code Extensions view showing the Livt extension published by Eccelerators and its Install button. — Select Livt by Eccelerators. Installing the extension adds the editor integration; the walkthrough prepares the compiler and supporting tools next.

You can also open the Livt Marketplace listing. If you prefer the VS Code command-line launcher, use:

bash

code --install-extension eccelerators.vscode-livt

Open the walkthrough

Open Get Started with Livt. If it does not appear automatically, open the Command Palette with Ctrl + Shift + P, run Welcome: Open Walkthrough..., and select Get Started with Livt. You can return through the same command whenever you need it.

Begin with Connect your Eccelerators account. Select Sign in to Eccelerators in the walkthrough, complete sign-in in your browser, and return to VS Code. This gives the installer access to the software and licences available to your account. Once the tools and a valid licence are installed, local workflows do not require you to remain signed in.

Get Started with Livt walkthrough with Connect your Eccelerators account selected and the sign-in link visible. — Select a step on the left to read its guidance and use its actions on the right. The first three steps prepare the development environment.

Install the toolchain

Next, select Install the Livt toolchain and use the installation link in that step. Follow the prompts to prepare a compatible Java runtime and install Livt, HxS, and the licences available to your account. HxS is installed alongside Livt for the integrated register-interface workflow; you do not need to use it in every project.

The installer also offers GHDL, the default local simulator. Install it if you want to run the test in Hello, Livt!. FPGA vendor tools are not needed for this setup or for that simulation.

Get Started with Livt walkthrough with Install the Livt toolchain selected and links to install or manage the tools. — Use Install the Livt toolchain for initial setup. If the tools are already installed, use Manage an existing installation instead of reinstalling them.

Check the installation

Return to the walkthrough and select Check the installation. Its check action opens the extension diagnostics, where you can review tool availability, licences, and language-server status. Resolve any missing requirements for the workflow you intend to use; in particular, check that GHDL is available before running the tutorial's test.

You can reopen the same check at any time with Livt: Show Extension Diagnostics. If you enabled terminal access, you can also confirm that the compiler starts:

bash

livt --version

Once setup is ready, continue with Hello, Livt! to create a component, build it, and run its test. The remaining walkthrough steps introduce project creation, building, testing, vendor integration, and Livt Agent; they are development guidance, not additional installation requirements. For an overview of the editor's controls, see VS Code Workspace.

Manual installation

Manual installation gives you direct control over the compiler, dependencies, and surrounding development environment. It is particularly useful for automated build systems, CI runners, development servers, and environments where software versions are managed centrally.

Download the appropriate Livt distribution from Account Downloads.

Install the complete archive. The compiler, command-line launchers, and generator extensions are distributed together and must remain compatible.

Prerequisites

A minimal command-line installation needs the Livt distribution and a compatible Java runtime. Additional tools are needed only for particular workflows, such as simulation or FPGA implementation.

Requirement	Purpose	Needed for
Supported 64-bit Linux or Windows environment	Runs the Livt toolchain	All manual installations
Compatible Java runtime	Executes the compiler and related tools	All manual installations
Valid Livt licence	Authorises licensed operations	Licensed operations
GHDL simulator	Runs the default local simulation workflow	`livt test`
HxS compiler	Supports HxS-based register-interface generation	Projects that use HxS
FPGA vendor tools	Synthesis, implementation, timing analysis, and programming	Target-device implementation

The Java version must be compatible with the downloaded Livt distribution. Check that Java is available:

bash

java -version

If Java is not found, install a compatible runtime and configure the environment before continuing.

Manual installation on Linux

On Linux, install Livt in your home directory so the compiler can be used without administrator privileges. The following commands assume a standard user installation.

Download and extract Livt

Start by placing the complete distribution in ~/.livt. Keeping the archive together ensures that the launcher and its generator extensions stay compatible.

Download livt.tar.gz from Account Downloads, then extract the full archive:

bash

mkdir -p "${HOME}/.livt"
tar -xzf "${HOME}/Downloads/livt.tar.gz" -C "${HOME}/.livt"
chmod +x "${HOME}/.livt/livt"

These commands assume the archive is in ~/Downloads and contains the livt launcher at its top level.

Configure your environment

Your shell needs to know where the livt launcher is located. Adding the installation directory to PATH lets you run livt from any project directory.

Add the Livt directory to your user PATH:

bash

echo 'export PATH="${HOME}/.livt:${PATH}"' >> "${HOME}/.profile"
. "${HOME}/.profile"

If Java is installed outside the system path, configure JAVA_HOME and add its bin directory to PATH for the account that runs Livt.

Verify the compiler

Open a new terminal or reload your shell configuration, then ask Livt to report its version. This confirms that the launcher can be found and started.

bash

livt --version

If the command is not found, check the installation directory and confirm that your current shell has loaded the updated PATH.

Manual installation on Windows

On Windows, you can install Livt into your user profile without changing the system-wide toolchain. The steps below use the same per-user layout as the Linux installation.

Download and extract Livt

Extract the full distribution into your user profile. Keep all files from the archive together so the launcher and compiler extensions remain compatible.

Download livt.zip from Account Downloads. Extract the complete archive to:

text

%USERPROFILE%\.livt

Keep the directory structure provided by the archive intact.

Configure your environment

Windows needs the Livt installation directory on Path to find the command from PowerShell, Command Prompt, or automation scripts.

Add the following directory to your user Path environment variable:

text

%USERPROFILE%\.livt

If Java is not detected automatically, configure JAVA_HOME to point to the compatible Java runtime. Restart open terminals and development tools after changing environment variables.

Verify the compiler

A new terminal session picks up the updated environment variables. Check that the installed launcher starts and reports its version.

Open a new PowerShell or Command Prompt:

powershell

livt --version

If the command is not recognised, verify the extraction directory and user Path configuration.

Install and inspect licences

Licences determine which Eccelerators products and capabilities are available. Depending on the permissions granted to your account, a single licence may cover Livt, HxS, packages, and Livt Agent.

Managed installation

With the managed installation, licences are retrieved through the same interface used for tool setup, so there is no need to copy licence files manually.

The walkthrough's installation flow retrieves the licences available to your signed-in account. To inspect or refresh them later, run Livt: Manage Livt Installation, select Licenses, and choose Install or Refresh Licenses when needed.

Manual installation

In a terminal-only environment, store the downloaded licence file in Livt’s user licence directory. The compiler can then inspect the installed permissions without needing the VS Code extension.

Download your licence from the account portal and place the unchanged license-{guid}.lic file in the appropriate directory:

Platform	Licence directory
Linux	`~/.livt/licenses`
Windows	`%USERPROFILE%\.livt\licenses`

Inspect the installed licences without exposing their JWT contents:

bash

livt -l

Install a simulator

Livt uses simulation-based testing as part of its development workflow. The default local simulator is GHDL, an open-source VHDL simulator.

The walkthrough's toolchain installation offers GHDL during setup. To add or manage it later, run Livt: Manage Livt Installation and select GHDL.

For a manual installation, install GHDL for your operating system, make its executable available on PATH, and verify it:

bash

ghdl --version

The default local simulation workflow is invoked with:

bash

livt test

Install GHDL before following Hello, Livt! if you want to run its test.

HxS integration

Livt integrates with HxS for register interfaces and bus-connected hardware components. Projects using HxS annotations require the HxS compiler and matching generator extensions.

The managed toolchain installation includes HxS alongside Livt. For manual environments, follow HxS Installation, then verify:

bash

hxsc --version

HxS is optional for ordinary Livt projects and is not required for the Hello, Livt! tutorial.

FPGA vendor tools

Livt generates synthesizable HDL for established FPGA development toolchains. Synthesis, place and route, timing analysis, and device programming are carried out using vendor software installed separately from Livt.

Supported vendor integration workflows include AMD Vivado, GOWIN EDA, and Lattice Radiant.

Install the required vendor application according to its manufacturer's instructions. Add its executable to PATH, or configure its path when creating the corresponding vendor integration.

Vendor tools are not required for writing, building, or simulating your Livt project. See Vendor Integration when you are ready to implement a design for a particular FPGA.

Verify your installation

Checking tool versions is a quick way to catch missing executables and environment-path problems before you create a project. Choose the checks that match your installation method and intended workflow.

For Visual Studio Code, run Livt: Show Extension Diagnostics and review the configured compiler, Java environment, simulator, and other products.

For a manual or CI installation, run:

bash

java -version
livt --version
livt -l

If you plan to run tests, also run:

bash

ghdl --version

If your project uses HxS:

bash

hxsc --version

Version checks confirm that the tools are accessible, but do not prove that every workflow is configured correctly. The best end-to-end check is to create a small project, build it, and run its tests. Hello, Livt! walks you through that process.

Update Livt

Keep the compiler and generator extensions compatible to support reliable, reproducible builds. You can update Livt directly from Visual Studio Code when using a managed installation; a manual archive replacement is not necessary in that case.

Update through Visual Studio Code

After initial setup, return to Livt: Manage Livt Installation for ongoing tool and licence management. Choose Update Livt to update the managed compiler installation, or select Java, GHDL, or Licenses to manage those parts individually. Restart the language server or compiler worker when requested.

Livt Installation menu showing Update Livt, Licenses, Java, and GHDL. — The walkthrough guides initial setup; the installation manager is where you return for updates and licence management.

The Livt VS Code extension itself is updated separately through the normal Visual Studio Code Extensions view (or your configured extension auto-update settings). Keeping the extension updated helps ensure that its installation manager and editor integrations remain current.

Update a manual installation

Manual installations are updated by replacing the distribution files. Update the complete compiler and generator set together rather than mixing files from different releases.

Download the current distribution archive for your operating system from Account Downloads.

Replace the compiler, launcher, and generator files together rather than updating individual JAR files. Before replacing the installation, back up any files you need to retain, including:

Licences stored in licenses/.
Locally maintained configuration.
Other user-managed files in the installation directory.

Verify the compiler again:

bash

livt --version

Start developing

For a visual introduction to the editor, see VS Code Workspace. It shows where to find the project views, account controls, installation commands, and test feedback.

Your environment is ready for the next step: Hello, Livt!, where you will create a project in Visual Studio Code, implement a component, run its test, and explore the generated hardware.

For terminal-based development and automation, see the Livt CLI Reference.