Gram

Gram is a hard fork of Zed removing AI integration and telemetry as well as no user agreement or subscription, among other features. For more on the reasoning for and purpose of the fork see the mission statement. For general Gram information see the docs.

Installation

Gram is available in nixpkgs as gram. You can add it to system packages with

environment.systemPackages = with pkgs; [
  gram
];

Installing Extensions

Gram, unlike Zed, builds extensions locally. This makes getting extensions working on NixOS require some configuration. The two main ways are the adhoc method, or using nix-gram-extensions which currently requires home manager or hjem.

Adhoc Method

This allows you to use Gram as you'd expect on other distros, able to click Install From URL or Install Local and have Gram compile the extension. This method is definitely more hacky, so if you don't mind managing your extensions with nix, #Nix-Gram-Extensions is recommended.

There are a number of known things needed for Gram to successfully compile extensions itself. Aside from #Nix-ld, which needs to be enabled in your system configuration, everything else can be installed either to system packages, in a devShell, user packages, home manager packages, etc. All examples are primarily for reference, and as such will only demonstrate installation to system packages. If you want to install using any of the previously listed methods, it should hopefully be fairly simple to translate to your method of choosing.

The known requirements are the following:

• #Nix-ld
• #Clang
• #Wasm32-Wasip2 Rust Toolchain
• #Other Needed Packages

Nix-ld

Nix-ld must be enabled on the system. This is because Gram pulls in the wasi-sdk for portions of the compilation, and the binaries it pulls are made for normal Linux distributions, meaning the linker path they look for doesn't exist without Nix-ld. Enabling it is as simple as adding the following to your configuration.

{
  programs.nix-ld.enable = true;
}

Clang

Clang must be installed and available under the cc alias, which is true as long as the wrapped clang (the ones referred to as clang-wrapper) is the one installed and it is not being overwritten by gcc.

You can verify if clang is configured correctly in your environment by opening Gram's terminal (ctrl+` or ctrl+shift+p > terminal panel: toggle) and running the following

clang --version
cc --version

Both should return with a version of clang.

Wasm32-Wasip2 Toolchain

A valid wasm32-wasip2 rust toolchain needs to be installed into your environment. This can be done declaratively with either fenix or rust-overlay. Or you can have Gram install the toolchain itself by installing rustup to your environment. The rustup option is less declarative, but much simpler if that doesn't bother you.

If you've installed with fenix or rust-overlay, you can confirm that it's installed correctly by entering Gram's terminal and running

ls $(rustc --print sysroot)/lib/rustlib

If in the command's output is a directory named wasm32-wasip2, it should be installed correctly and Gram will be able to detect it. If it's listed as wasm32-unknown-unknown, see Gram#Wasm32_Wrong_Target.

Rustup

To configure rustup, just run

rustup default stable

As whatever user is using Gram to add the stable toolchain as your default to ~/.rustup.

Fenix

This example uses the latest branch, but other options are available, just make sure the versions all match across toolchain and target or rustc, cargo and target.

Add fenix to your flake

❄︎ flake.nix

{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nixpkgs.url = "nixpkgs/nixos-unstable"; # or any other branch
  };
}

{inputs, pkgs, system, ... }:
  let
    extension-toolchain = with inputs.fenix.packages.${system}; combine [
# full toolchain (not required):
    # latest.toolchain
# minimum required to build:
      latest.rustc
      latest.cargo
# wasm32-wasip2 target (required):
      targets.wasm32-wasip2.latest.rust-std
    ];
  in
{
  environment.systemPackages = with pkgs; [
    clang
    extension-toolchain
  ];
}

Rust-Overlay

Like the fenix example, this assumes the latest branch, though rust-overlay provides others.

Add rust-overlay to your flake

❄︎ flake.nix

{
  inputs = {
    fenix = {
      url = "github:nix-community/fenix";
      inputs.nixpkgs.follows = "nixpkgs";
    };
    nixpkgs.url = "nixpkgs/nixos-unstable"; # or any other branch
  };
}

{ inputs, pkgs, ... }:
{
  nixpkgs.overlays = [ inputs.rust-overlay.overlays.default ];
  environment.systemPackages = with pkgs; [
# full toolchain (not required):
    # (rust-bin.stable.latest.default.override { targets = [ "wasm32-wasip2" ]; })
# minimum required to build:
    (rust-bin.stable.latest.minimal.override { targets = [ "wasm32-wasip2" ]; })
  ];
}

Other Needed Packages

• git

Nix-Gram-Extensions

nix-gram-extensions is a project to bring declarative management of Gram extensions to Nix using custom builders and integration with home manager and hjem. It is hosted on codeberg and tangled. If you want to install it to your system, it has a detailed section on installation in its README. More information can be found at its discourse announcement.

More About Extensions

• NixOS Discourse: Fail To Add Extensions To Gram

Troubleshooting

Extensions

Wasm32 Wrong Target

If the wasm32 target is listed as wasm32-unknown-unknown, Gram will be unable to detect it and if rustup isn't installed it will error with failed to run `rustup target add`: no such file or directory, because when it doesn't detect an installed valid toolchain, it tries to install one with rustup. This has happened on fenix's stable branch and was fixed by changing to the latest branch.