Skip to content

A powerful new shell that uses the janet programming language for both the implementation and repl.


Notifications You must be signed in to change notification settings


Folders and files

Last commit message
Last commit date

Latest commit


Repository files navigation




Mailing list


A new system shell that uses the Janet programming language for high level scripting while also supporting the things we love about sh.

Minimal knowledge of janet is required for basic shell usage, but know that as you become more familiar with janet, your shell will gain the power of:

  • A powerful standard library.
  • Functional and imperative programming.
  • Powerful lisp macros.
  • Runtime loadable extension modules written in C/C++/rust/zig...
  • Coroutines and exceptions.
  • Much much more.

Help develop janetsh donate via paypal


Janetsh development has slowed and I am not actively working on it for now. Some of it is no longer compatible with the latest janet release.

That being said, I consider janetsh a successful proof of concept and place to draw code and ideas from whenever the next attempt at fixing shells gets my attention.

One potential avenue for janetsh2 in the future is to integrate janet syntax with the shell library:

If we do this, we can have POSIX compatibility when we need it, as well as avoid implementing most of the complexity in a shell, and can instead focusing on delivering on the important ideas of janetsh.

See it in action


demo source code demo rc file


Basic shell usage

As you would expect:

$ ls -la | head -n 3
total 100
drwxr-xr-x 1 ac users   220 May 13 20:16 .
drwxr-xr-x 1 ac users   760 May 12 21:08 ..

$ echo foo > /dev/null

$ sleep 5 &
@{:pgid 82190 :procs @[@{:args @["sleep" "5"]
      :pid 82190
      :stopped false
      :redirs @[]}]}

$ rm ./demos/*.gif

Functional programming

$ (map string/ascii-upper ["functional" "programming"])

$ (defn lines [s] (string/split "\n" s))
<function lines>

$ (lines ($$ ls | head -n 3))
@["" "demos" "janetsh" ""]

$ echo (reduce + 0 [1 2 3])

Command capture

$ (string/ascii-upper ($$ echo command string capture))

$ ($$_ echo trimmed capture)
"trimmed capture"

$ (if (= 0 ($? touch /tmp/test.txt)) "success")

$ (if ($?? touch /tmp/test.txt) "shorthand success")
"shorthand success"


$ (try
      ($ rm foo.txt)
      ($ rm bar.txt)
      ($ rm baz.txt))
    ([err] (print "got an error:" err)))

Mixing janet code and shell commands

$ (each f files (sh/$ wc -l [f]))


$ ls | head -n 3 | (out-lines string/ascii-upper)

Reference Documentation

Hopefully in the future this sparse reference set will become more polished, but for now the following snippets may help advanced users play with the shell in it's current state.

RC files

Janetsh runs a user rc script ~/.janetsh.rc at startup when in interactive mode. This file can changed or disabled via command line flags.

Janetsh runs /etc/janetsh.rc on any run if it exists. This file can be changed or disabled via command line flags.

Custom prompts

Users can set a custom prompt:

(set *get-prompt* (fn [p] "$ "))

p is a janet standard library parser, which can be used to find the current repl nesting level.

Custom line completions

Users can set a custom line completion function:

(set *get-completions*
  (fn [line word-start word-end]

History file

By default janetsh does not store any history to avoid accidental information leaks.

To enable history add the following line to your janet rc file:

(set *hist-file* (first (sh/expand "~/.janetsh.hist")))

Job control

A list of running jobs can be found in the variable sh/jobs, each of which is a janet table containing the current state of a user job/pipeline.

The sh package has some functions for manipulating jobs, such as putting them in the foreground, or terminating them. This is not a stable interface for now, so you will need to read the code yourself for documentation.

Some examples:

$ (sh/fg-job (first sh/jobs))
$ sleep 60 &
$ (sh/terminate-all-jobs)
$ (sh/disown-job (sh/$ sleep 60 &))

Custom builtin shell commands

Here is an example of defining a new builtin shell command.

(defn- make-my-builtin
      (fn pre-fork
        [self args]
        (print "hello from shell process"))
      (fn post-fork
        [self args]
        (print "hello from child process"))

(put sh/*builtins* "my-builtin" make-my-builtin)

It is important to catch any errors and only report them from the child process. This means builtins can manipulate the shell internal state, but still behave like regular processes for the purpose of exit codes, pipes and job control.


For the default build you will need pre released janet 1.0.0 built from source, readline and pkg-config installed on your system, then you can run:

./configure && make install

If you want libedit instead of readline you can build with:

./configure --with-pkg-config-libedit

If you don't want to depend on readline or libedit, you can use the bundled emulation.

./configure --with-readnoise

You can also manually specify header paths, install paths and flags.

Try ./configure --help for a list of options.

Janetsh Internals

Internally janetsh is implemented as a low level C library for the janet programming language, a janet library and a small launcher that does some necessary setup/teardown.

The janet main implementation is a set of janet functions and macros that perform shell job control, control user input and manage your command pipelines.

At the highest level the user is presented with an interactive repl interface which implicitly invokes a janet macro to give janet the familiar sh syntax. You can escape this implicit macro by prefixing a line with '(' which reverts to regular janet mode.

Janetsh can also be used for scripting, in which case it acts a small job control runtime and launcher for janet programs.

Project Status and Donations

The project is at the proof of concept phase and is only usable by people brave and willing to fix things for themselves.

The author would love donations or help from fellow developers to keep things going forward. Donations will go towards living expenses while developing janetsh and providing upstream support for the janet programming language issues that affect Janetsh.

This project takes considerable time an effort, please donate here via paypal to keep the project alive.

At your request with each donation leave a message and if appropriate, it will be included below.


You - Your message


This project is being built with care by Andrew Chambers.


Special thanks to Calvin Rose for creating the Janet programming language.

Thanks to the authors of closh, rash and xonsh for providing inspiration for the project.


A powerful new shell that uses the janet programming language for both the implementation and repl.








No releases published


No packages published