Small Clojure interpreter, linter and formatter.


Joker is a small Clojure interpreter, linter and formatter written in Go.


On macOS, the easiest way to install Joker is via Homebrew:

brew install candid82/brew/joker

The same command can be used on Linux if you use Linuxbrew.

If you use Arch Linux, there is AUR package.

If you use Nix, then you can install Joker with

nix-env -i joker

On other platforms (or if you prefer manual installation), download a precompiled binary for your platform and put it on your PATH.

You can also build Joker from the source code.


joker - launch REPL. Exit via (exit), EOF (such as Ctrl-D), or SIGINT (such as Ctrl-C).

joker <filename> - execute a script. Joker uses .joke filename extension. For example: joker foo.joke. Normally exits after executing the script, unless --exit-to-repl is specified before --file <filename> in which case drops into the REPL after the script is (successfully) executed. (Note use of --file in this case, to ensure <filename> is not treated as a <socket> specification for the repl.)

joker --eval <expression> - execute an expression. For example: joker -e '(println "Hello, world!")'. Normally exits after executing the script, unless --exit-to-repl is specified before --eval, in which case drops into the REPL after the expression is (successfully) executed.

joker - - execute a script on standard input (os.Stdin).

joker --lint <filename> - lint a source file. See Linter mode for more details.

joker --lint --working-dir <dirname> - recursively lint all Clojure files in a directory.

joker --format <filename> - format a source file and write the result to standard output. See Format mode for more details.

joker --format - - read Clojure source code from standard input, format it and print the result to standard output.


Standard library reference

Dash docset: dash-feed://

(either copy and paste this link to your browser's url bar or open it in a terminal with open command)

Joker slack channel

Organizing libraries (namespaces)

Developer notes

Project goals

These are high level goals of the project that guide design and implementation decisions.

  • Be suitable for scripting (lightweight, fast startup). This is something that Clojure is not good at and my personal itch I am trying to scratch.
  • Be user friendly. Good error messages and stack traces are absolutely critical for programmer's happiness and productivity.
  • Provide some tooling for Clojure and its dialects. Joker has linter mode which can be used for linting Joker, Clojure and ClojureScript code. It catches some basic errors. Joker can also format (pretty print) Clojure code (see format mode) or EDN data structures. For example, the following command can be used to pretty print EDN data structure (read from stdin):
joker --hashmap-threshold -1 -e "(pprint (read))"

There is Sublime Text plugin that uses Joker for pretty printing EDN files. Here you can find the description of --hashmap-threshold parameter, if curious.

  • Be as close (syntactically and semantically) to Clojure as possible. Joker should truly be a dialect of Clojure, not a language inspired by Clojure. That said, there is a lot of Clojure features that Joker doesn't and will never have. Being close to Clojure only applies to features that Joker does have.

Project Non-goals

  • Performance. If you need it, use Clojure. Joker is a naive implementation of an interpreter that evaluates unoptimized AST directly. I may be interested in doing some basic optimizations but this is definitely not a priority.
  • Have all Clojure features. Some features are impossible to implement due to a different host language (Go vs Java), others I don't find that important for the use cases I have in mind for Joker. But generally Clojure is a pretty large language at this point and it is simply unfeasible to reach feature parity with it, even with naive implementation.

Differences with Clojure

  1. Primitive types are different due to a different host language and desire to simplify things. Scripting doesn't normally require all the integer and float types, for example. Here is a list of Joker's primitive types:
Joker type Corresponding Go type
BigFloat big.Float
BigInt big.Int
Boolean bool
Char rune
Double float64
Int int
Keyword n/a
Nil n/a
Ratio big.Rat
Regex regexp.Regexp
String string
Symbol n/a
Time time.Time

Note that Nil is a type that has one value nil.

  1. The set of persistent data structures is much smaller:
Joker type Corresponding Clojure type
ArrayMap PersistentArrayMap
MapSet PersistentHashSet (or hypothetical PersistentArraySet, depending on which kind of underlying map is used)
HashMap PersistentHashMap
List PersistentList
Vector PersistentVector
  1. Joker doesn't have the same level of interoperability with the host language (Go) as Clojure does with Java or ClojureScript does with JavaScript. It doesn't have access to arbitrary Go types and functions. There is only a small fixed set of built-in types and interfaces. Dot notation for calling methods is not supported (as there are no methods). All Java/JVM specific functionality of Clojure is not implemented for obvious reasons.
  2. Joker is single-threaded with no support for parallelism. Therefore no refs, agents, futures, promises, locks, volatiles, transactions, p* functions that use multiple threads. Vars always have just one "root" binding. Joker does have core.async style support for concurrency. See go macro documentation for details.
  3. The following features are not implemented: protocols, records, structmaps, chunked seqs, transients, tagged literals, unchecked arithmetics, primitive arrays, custom data readers, transducers, validators and watch functions for vars and atoms, hierarchies, sorted maps and sets.
  4. Unrelated to the features listed above, the following function from clojure.core namespace are not currently implemented but will probably be implemented in some form in the future: subseq, iterator-seq, reduced?, reduced, mix-collection-hash, definline, re-groups, hash-ordered-coll, enumeration-seq, compare-and-set!, rationalize, load-reader, find-keyword, comparator, resultset-seq, file-seq, sorted?, ensure-reduced, rsubseq, pr-on, seque, alter-var-root, hash-unordered-coll, re-matcher, unreduced.
  5. Built-in namespaces have joker prefix. The core namespace is called joker.core. Other built-in namespaces include joker.string, joker.json, joker.os, joker.base64 etc. See standard library reference for details.
  6. Joker doesn't support AOT compilation and (-main) entry point as Clojure does. It simply reads s-expressions from the file and executes them sequentially. If you want some code to be executed only if the file it's in is passed as joker argument but not if it's loaded from other files, use (when (= *main-file* *file*) ...) idiom. See for details.
  7. Miscellaneous:
  • case is just a syntactic sugar on top of condp and doesn't require options to be constants. It scans all the options sequentially.
  • slurp only takes one argument - a filename (string). No options are supported.
  • ifn? is called callable?
  • Map entry is represented as a two-element vector.
  • resolving unbound var returns nil, not the value Unbound. You can still check if the var is bound with bound? function.

Linter mode

To run Joker in linter mode pass --lint --dialect <dialect> flag, where <dialect> can be clj, cljs, joker or edn. If --dialect <dialect> is omitted, it will be set based on file extension. For example, joker --lint foo.clj will run linter for the file foo.clj using Clojure (as opposed to ClojureScript or Joker) dialect. joker --lint --dialect cljs - will run linter for standard input using ClojureScript dialect. Linter will read and parse all forms in the provided file (or read them from standard input) and output errors and warnings (if any) to standard output (for edn dialect it will only run read phase and won't parse anything). Let's say you have file test.clj with the following content:

(let [a 1])

Executing the following command joker --lint test.clj will produce the following output:

test.clj:1:1: Parse warning: let form with empty body

The output format is as follows: <filename>:<line>:<column>: <issue type>: <message>, where <issue type> can be Read error, Parse error, Parse warning or Exception.

Integration with editors

Here are some examples of errors and warnings that the linter can output.

Reducing false positives

Joker lints the code in one file at a time and doesn't try to resolve symbols from external namespaces. Because of that and since it's missing some Clojure(Script) features it doesn't always provide accurate linting. In general it tries to be unobtrusive and error on the side of false negatives rather than false positives. One common scenario that can lead to false positives is resolving symbols inside a macro. Consider the example below:

(ns foo (:require [bar :refer [def-something]]))

(def-something baz ...)

Symbol baz is introduced inside def-something macro. The code is totally valid. However, the linter will output the following error: Parse error: Unable to resolve symbol: baz. This is because by default the linter assumes external vars (bar/def-something in this case) to hold functions, not macros. The good news is that you can tell Joker that bar/def-something is a macro and thus suppress the error message. To do that you need to add bar/def-something to the list of known macros in Joker configuration file. The configuration file is called .joker and should be in the same directory as the target file, or in its parent directory, or in its parent's parent directory etc up to the root directory. When reading from stdin Joker will look for a .joker file in the current working directory. The --working-dir <path/to/file> flag can be used to override the working directory that Joker starts looking in. Joker will also look for a .joker file in your home directory if it cannot find it in the above directories. The file should contain a single map with :known-macros key:

{:known-macros [bar/def-something foo/another-macro ...]}

Please note that the symbols are namespace qualified and unquoted. Also, Joker knows about some commonly used macros (outside of clojure.core namespace) like clojure.test/deftest or clojure.core.async/go-loop, so you won't have to add those to your config file.

Joker also allows you to specify symbols that are introduced by a macro:

{:known-macros [[riemann.streams/where [service event]]]}

So each element in :known-macros vector can be either a symbol (as in the previous example) or a vector with two elements: macro's name and a list of symbols introduced by this macro. This allows to avoid symbol resolution warnings in macros that intern specific symbols implicitly.

Additionally, if you want Joker to ignore some unused namespaces (for example, if they are required for their side effects) you can add the :ignored-unused-namespaces key to your .joker file:

{:ignored-unused-namespaces []}

Sometimes your code may refer to a namespace that is not explicitly required in the same file. This is rarely needed, but if you face such situation you can add that namespace to :known-namespaces list to avoid "No namespace found" or "Unable to resolve symbol" warnings:

{:known-namespaces [clojure.spec.gen.test]}

If your code uses tagged literals that Joker doesn't know about, add them to :known-tags list:

{:known-tags [db/fn]}

If you use :refer :all Joker won't be able to properly resolve symbols because it doesn't know what vars are declared in the required namespace (i.e. clojure.test). There are generally three options here:

  1. Refer specific symbols. For example: [clojure.test :refer [deftest testing is are]]. This is usually not too tedious, and you only need to do it once per file.
  2. Use alias and qualified symbols:
(:require [clojure.test :as t])
(t/deftest ...)
  1. "Teach" Joker declarations from referred namespace. Joker executes the following files (if they exist) before linting your file: .jokerd/linter.cljc (for both Clojure and ClojureScript), .jokerd/linter.clj (Clojure only), .jokerd/linter.cljs (ClojureScript only), or .jokerd/linter.joke (Joker only). The rules for locating .jokerd directory are the same as for locating .joker file.

    • ⚠️ Joker can be made aware of any additional declarations (like deftest and is) by providing them in .jokerd/linter.clj[s|c] files. However, this means Joker cannot check that the symbols really are declared in your namespace, so this feature should be used sparingly.
    • If you really want some symbols to be considered declared in any namespace no matter what, you can add (in-ns 'joker.core) to your linter.clj[s|c] and then declare those symbols. (see issues 52 and 50 for discussion).

I generally prefer first option for clojure.test namespace.

Linting directories

To recursively lint all files in a directory pass --working-dir <dirname> parameter. Please note that if you also pass file argument (or --file parameter) Joker will lint that single file and will only use --working-dir to locate .joker config file. That is,

joker --lint --working-dir my-project

lints all Clojure files in my-project directory, whereas

joker --lint --working-dir my-project foo.clj

lints single file foo.clj but uses .joker config file from my-project directory.

When linting directories Joker lints all files with the extension corresponding to the selected dialect (*.clj, *.cljs, *.joke, or *.edn). To exclude certain files specify regex patterns in :ignored-file-regexes vector in .joker file, e.g. :ignored-file-regexes [#".*user\.clj" #".*/dev/profiling\.clj"].

When linting directories Joker can report globally unused namespaces and public vars. This is turned off by default but can be enabled with --report-globally-unused flag, e.g. joker --lint --working-dir my-project --report-globally-unused. This is useful for finding "dead" code. Some namespaces or vars are intended to be used by external systems (e.g. public API of a library or main function of a program). To exclude such namespaces and vars from being reported as globally unused list them in :entry-points vector in .joker file, which may contain the names of namespaces or fully qualified names of vars. For example:

{:entry-points [my-project.public-api

Optional rules

Joker supports a few configurable linting rules. To turn them on or off set their values to true or false in :rules map in .joker file. For example:

{:rules {:if-without-else true
         :no-forms-threading false}}

Below is the list of all configurable rules.

Rule Description Default value
if-without-else warn on if without the else branch false
no-forms-threading warn on threading macros with no forms, i.e. (-> a) true
unused-as warn on unused :as binding true
unused-keys warn on unused :keys, :strs, and :syms bindings true
unused-fn-parameters warn on unused fn parameters false
fn-with-empty-body warn on fn form with empty body true

Note that unused binding and unused parameter warnings are suppressed for names starting with underscore.

Valid Identifiers

Symbols and keywords (collectively referred to herein as "identifiers") can be comprised of nearly any encodable character ("rune" in Go), especially when composed from a String via e.g. (symbol "arbitrary-string").

Unlike most popular programming languages, Clojure allows "extreme flexibility" (as does Joker) in choosing characters for identifiers in source code, permitting many control and other invisible characters, even as the first character. In short, any character not specifically allocated to another purpose (another lexeme) by the Clojure language defaults to starting or continuing an identifier lexeme: (def ^@ "test"), where ^@ denotes the ASCII NUL (0x00) character, works.

When linting an identifier (versus composing one at runtime), Joker ensures its characters are members of a more "reasonable" set, aligned with those used by the core libraries of Clojure (as well as Joker).

This "core set" of characters, as a Regex, is #"[a-zA-Z0-9*+!?<=>&_.'-]". It represents the intersection of a limited set of letters, digits, symbols, and punctuation within the (7-bit) ASCII encoding range. The letters are the ASCII-range members of Unicode category L, while the digits are the ASCII-range members of category Nd.

Thus, Joker will warn about using an em dash (instead of an ASCII hyphen-minus (0x2D)), a non-breaking space (&nbsp; in HTML), an accented letter (e.g. é), or a control character (even NUL), in an identifier.

The .joker file may specify key/value pairs that change this default:

Key Value Meaning
:character-set :core #"[*+!?<=>&_.'\-$:#%]" plus categories L and Nd
:symbol :core plus symbols (category S)
:visible :symbol plus punctuation (P) and marks (M)
:any any category
:encoding-range :ascii only 7-bit ASCII (<= unicode.MaxASCII)
:unicode only Unicode (<= unicode.MaxRune)
:any any encodable character

The intersection of these specifications governs how identifiers are linted; any character outside the resulting set yields a linter warning.

If :valid-ident is not fully specified, the defaults are the core character set in the ASCII range, as if .joker contained:

{:valid-ident {:character-set :core
               :encoding-range :ascii}}

Changing :core to :symbol would allow, for example, | in identifiers; whereas changing :ascii to :unicode would allow é.

Format mode

To run Joker in format mode pass --format flag. For example:

joker --format <filename> - format a source file and write the result to standard output.

joker --format - - read Clojure source code from standard input, format it and print the result to standard output.

Integration with editors


Joker requires Go v1.13 or later. Below commands should get you up and running.

go get -d
cd $GOPATH/src/
./ --version && go install

Cross-platform Builds

After building the native version (to autogenerate appropriate files, "vet" the source code, etc.), set the appropriate environment variables and invoke go build. E.g.:

$ GOOS=linux GOARCH=arm GOARM=6 go build

The script does not support cross-platform building directly, but can be used in conjunction with to cross-build from a Linux amd64 or 386 system to a Linux arm system via:

$ ./ --version && ./

Note that cross-building from 64-bit to 32-bit machines (and vice versa) is problematic due to the gen_code step of building Joker. This step builds a faster-startup version of Joker than was built in earlier versions, prior to the introduction of gen_code. It does this by building much of Joker code into gen_code itself, running the (expensive) dynamic-initialization code to build up core namespaces from (nearly) scratch, then using reflection to discover the resulting data structures and output their contents as Go code that (mostly) statically recreates them when built into the Joker executable itself. (See for more information on gen_code.)

As types such as int are 32-bit on 32-bit machines, and 64-bit on 64-bit machines, the final Joker executable must be built with code generated by a same-word-size build of gen_code. Otherwise, compile-time errors might well result due to too-large integers; or, run-time errors might result due to too-small integers.

Since Linux (on amd64) supports building and running 32-bit (386) executables, it's a good candidate for cross-building to 32-bit architectures such as arm.

Coding Guidelines

  • Dashes (-) in namespaces are not converted to underscores (_) by Joker, so (unlike with Clojure) there's no need to name .joke files accordingly.
  • Avoid :refer :all and the use function, as that reduces the effectiveness of linting.

Developer Notes

See for information on Joker internals, such as adding new namespaces to the Joker executable.


Copyright (c) Roman Bataev. All rights reserved.
The use and distribution terms for this software are covered by the
Eclipse Public License 1.0 (
which can be found in the LICENSE file.

Joker contains parts of Clojure source code (from clojure.core namespace). Clojure is licensed as follows:

Copyright (c) Rich Hickey. All rights reserved.
The use and distribution terms for this software are covered by the
Eclipse Public License 1.0 (
which can be found in the file epl-v10.html at the root of this distribution.
By using this software in any fashion, you are agreeing to be bound by
the terms of this license.
You must not remove this notice, or any other, from this software.
  • RFC: Markdown Rendering Support

    RFC: Markdown Rendering Support

    Hello there,

    I have been using joker for a while now and have found it extremely useful for automating a number of chores, but needed it to be able to render markdown, so I did some research into the status quo of Go parsers and found goldmark to both have everything that was required and also a very nicely laid out approach.

    I've tried adding other things to joker in the past (most notably SQLite - see #245 and #252), and this is comparatively much less complex, but perhaps more generally useful (and yes, I'll try having a go at SQLite again sometime soon...)

    I've added docs as well (such as they are), but am uncertain of how to go about doing test coverage - so feel free to comment.

  • Support Class Paths

    Support Class Paths

    This addresses, and also adds a barebones joker.repl (doc works).

    There's a lot to unpack here, including various random decisions I made about how things should work, while trying to be compatible with existing installations and usage of Joker.

    As I couldn't get a handle on how the Go ecosystem handles installation of artifacts that accompany (but are not to be embedded in) the executable, I kinda winged it, in part by creating an script that wraps go install for purposes of installing artifacts in a "canonical" location (that might be problematic).

    I'm accustomed to (if not thrilled by) the autoconf world where ./configure --prefix= and friends would set things like this up, the resulting make-built executable(s) would have the prefix info internally, and everything could then be magically packaged up.

    If there's a similar mechanism for the world of Go, it didn't reveal itself during my searches.

  • Linter Support for Validating Symbol/Keyword Characters

    Linter Support for Validating Symbol/Keyword Characters

    This is one approach to addressing

    Note that it changes Joker behavior in that it (by default) disallows em dashes, glyphs/graphics, and other such things in symbol/keyword names.

    While that would make Joker less compatible with Clojure, I think it'd make a better argument for Joker as an effective linting and formatting tool, as it seems (to me) very unlikely any developers actually want such characters in symbol or keyword names in their source code.

    But that default could be easily changed (to --valid-letters unicode) if stricter compatibility, out of the box, is desired.

    If --valid-letters ascii is considered useful to/by some users, it might make sense to add a --valid-digits option to specify either unicode (the default) or ascii (only [0-9]); that possibility weighed on the decision on how to name --valid-letters. Limiting valid digits to only ASCII would affect parsing of not only symbol and keyword names, but (I would think) of numbers as well.

  • eval/stdin-pipe Fails On Linux amd64 With Empty Output

    eval/stdin-pipe Fails On Linux amd64 With Empty Output

    So far I've reduced this to a simple one-liner that shows the string not appearing in the output when passed via stdin, while it works when the string is provided directly via the :stdin keyword:

    $ ./joker -e '(println (joker.os/exec "cat" {:stdin :pipe}))' <<< "this is a test"
    {:success true, :exit 0, :out , :err }
    $ ./joker -e '(println (joker.os/exec "cat" {:stdin "this is a test"}))'
    {:success true, :exit 0, :out this is a test, :err }

    This is on my Ubuntu server:

    Linux dove 4.4.0-142-generic #168-Ubuntu SMP Wed Jan 16 21:00:45 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux
    go version go1.11.7 linux/amd64

    It doesn't appear to be a shell issue or anything else fundamental like that:

    $ ./joker -e "(read-line)" <<< "this is a test"
    "this is a test"

    (it works fine on my Mac OS X.)

  • Support -main/entry point

    Support -main/entry point

    Today you have to execute (-main) (or another function) to start you script. This however leads to issues when doing unit testing etc. This can be worked around today with *main-file*, *file* but we should support doing this the standard Clojure™ way.

  • Shave milliseconds off startup time.

    Shave milliseconds off startup time.

    Currently, launching a minimal joker script takes 30~40 milliseconds. While this is ok for a self-contained script, requiring other scripts or calling it from a loop is going to slow joker down.

    Launching babashka takes 2 milliseconds after loading the binary onto cache.

    I have a few naive ideas on shaving startup time.

    • Separate non-essential namespaces into modules
    • Compile modules into joker bytecode.
    • ...
  • TESTING: add primitive support for MX lookups

    TESTING: add primitive support for MX lookups

    This is DRAFT work, not appropriate for merging as a PR, because we hope to automate adding a bunch of Go runtime packages using this model, and that'd include net/LookupMX.

    But this opens up the approach I'm taking for discussion.

  • Evaluate 'gostd' Fork

    Evaluate 'gostd' Fork

    Much progress made over the past two weeks, thanks to a new workstation (powered by a Ryzen 3900x, much faster than the 8-year-old i7 that got dropped by the movers back in May).

    Though there's still much left to do, I'll be on vacation for much of the next couple of weeks. So I've tried to get enough stuff working to ask for feedback on this:

    See snapshots of some per-target namespace docs at:

    The "big things" accomplished the past two weeks include autowrapping:

    • Some receivers (no docstrings are generated for these)

    • Most constants

    • All variables

    The performance hit seems to be roughly 25% more startup time on my machines. I hope to find ways to improve startup performance here, or in Joker generally, later this year.

    In the meantime, I welcome feedback as to how usable this is, what are the most urgent "asks", and so on. (I'll be coming up with my own answers as I put this version into wider use in my own (production environment.)

  • "Unable to resolve symbol: deftest" when using `:refer :all`

    I'm using flycheck-joker in spacemacs and I'm very happy with what it provides. However, one thing that bothers me quite a lot is that joker reports deftest and is as unresolved symbols. Here's the minimal repro for me:

    (ns myapp.util-test
      (:require [myapp.util :as u]
                     [clojure.test :refer :all]))
    (deftest namespaced-map
      (testing "keys are namespaced"
        (let [unqualified-keys {:name "Juraj" :age 32}
              qualified-keys #:user{:name "Juraj" :age 32}]
          (is (= qualified-keys unqualified-keys)))))

    Here's the screenshot: image

    I realized that this might be because deftest and is are macros so I tried to add following to ~/.joker (inspired by

    {:known-macros [clojure.test/deftest clojure.test/testing clojure.test/is clojure.test/are]}

    No success, however.

    Any ideas why that happens? Is it something that should work out of the box?

  • limitations of only being able to pass a single flag to the linter

    limitations of only being able to pass a single flag to the linter

    I recently wrote a linter for (a vim plugin for async linting). Joker works really really well for this due to it's fast startup speed and nice outputs.

    However having spent a couple of days using it I started running into an issue where joker didn't seem to detect my .joker file. Looking deeper into the issue, I found it was because ale was writing the contents of my file to a /tmp/xzy.clj file then linting that, loosing the context of the original sources directory and thus its .joker file.

    Swapping the ale linter to pipe the files contents to stdin worked... until I changed directory and again lost the context of my working directory. finally frustrated I swapped the linter to just read the file off the disk and now it only works on saving the file.

    Ideally I would like to add a flag to the linter to parse in the config directly:

    joker --lint --config='{:known-macros [bar/def-something foo/another-macro ...]}' <filename/stdin>


    joker --lint --config='/path/to/file/.joker' <filename/stdin>


    joker --lint --working-dir='/path/to/file/' <filename/stdin>

    however the current main doesn't leave much leeway in terms of adding additional flags.

    Instead of parsing os.Args manually something along the lines of the flag lib would give more flexibility. I had a mess about last night converting it use pflag just to see if it would work and it appears functional (if a bit ugly).

    Is this something that seems reasonable? I don't want to break anything in the repl/interpreter.

  • Support tab completion.

    Support tab completion.

    It would really help with REPL browsing.

    You can implement your own tab completion or use readline which adds various key bindings. The first tab should partially complete an input. The second tab should show completions.

  • Dynamically Discover Core Libraries?

    Dynamically Discover Core Libraries?

    Rather than maintain static lists of core namespaces and their source files in core/data/, consider structuring that directory as per usual Joker namespace rules and having gen_data (and/or gen_code) dynamically discover and process them.

    core/data/joker/core.joke would still be loaded first and treated specially, but the rest would be loaded as needed based on the usual (ns ...) specifications.

    While this would make official Joker more maintainable for the occasional addition of a core namespace, it could make Joker much more attractive to end users who wish to "compile", or embed, their own (or 3rd-party) libraries in the executable -- they could just drop the source code into the appropriate directory and rebuild.

Interpreter - The Official Interpreter for the Infant Lang written in Go

Infant Lang Interpreter Infant Lang Minimalistic Less Esoteric Programming Langu

Jan 10, 2022
Go bindings to QuickJS: a fast, small, and embeddable ES2020 JavaScript interpreter.

quickjs Go bindings to QuickJS: a fast, small, and embeddable ES2020 JavaScript interpreter. These bindings are a WIP and do not match full parity wit

Dec 28, 2022
Interactive Go interpreter and debugger with REPL, Eval, generics and Lisp-like macros

gomacro - interactive Go interpreter and debugger with generics and macros gomacro is an almost complete Go interpreter, implemented in pure Go. It of

Dec 30, 2022
Monkey programming language project from 'Writing An Interpreter In Go'and 'Writing A Compiler In Go' Books
Monkey programming language project from 'Writing An Interpreter In Go'and 'Writing A Compiler In Go' Books

Monkey Monkey programming language ?? project from "Writing An Interpreter In Go

Dec 16, 2021
Scriptable interpreter written in golang
Scriptable interpreter written in golang

Anko Anko is a scriptable interpreter written in Go. (Picture licensed under CC BY-SA 3.0, photo by Ocdp) Usage Example - Embedded package main impor

Dec 23, 2022
A POSIX-compliant AWK interpreter written in Go

GoAWK: an AWK interpreter written in Go AWK is a fascinating text-processing language, and somehow after reading the delightfully-terse The AWK Progra

Dec 31, 2022
A BASIC interpreter written in golang.
A BASIC interpreter written in golang.

05 PRINT "Index" 10 PRINT "GOBASIC!" 20 PRINT "Limitations" Arrays Line Numbers IF Statement DATA / READ Statements Builtin Functions Types 30 PRINT "

Dec 24, 2022
Prolog interpreter in Go

golog Prolog interpreter in Go with aspirations to be ISO compatible. See the full package documentation for usage details. Install with go get github

Nov 12, 2022
A simple virtual machine - compiler & interpreter - written in golang

go.vm Installation Build without Go Modules (Go before 1.11) Build with Go Modules (Go 1.11 or higher) Usage Opcodes Notes The compiler The interprete

Dec 17, 2022
A JavaScript interpreter in Go (golang)

otto -- import "" Package otto is a JavaScript parser and interpreter written natively in Go.

Jan 2, 2023
Yaegi is Another Elegant Go Interpreter
Yaegi is Another Elegant Go Interpreter

Yaegi is Another Elegant Go Interpreter. It powers executable Go scripts and plugins, in embedded interpreters or interactive shells, on top of the Go

Dec 30, 2022
Lisp Interpreter

golisp Lisp Interpreter Usage $ golisp < foo.lisp Installation $ go get Features Call Go functions. Print random in

Dec 15, 2022
Mini lisp interpreter written in Go.

Mini Go Lisp Mini lisp interpreter written in Go. It is implemented with reference to the d-tsuji/SDLisp repository written in Java. Support System Fu

Nov 25, 2022
Toy Lisp 1.5 interpreter

Lisp 1.5 To install: go get This is an implementation of the language defined, with sublime concision, in the first few pages of the

Jan 1, 2023
A interpreter of SweetLang, is writed in Go Programming language.

SweetLang ( Soon ) A interpreter of SweetLang, is writed in Go Programming language. SweetLang is made with clarity and simplicity we try to make its

Oct 31, 2021
interpreter for the basic language written in golang
interpreter for the basic language written in golang

jirachi interpreter for the basic language written in golang The plan supports the following functions: Arithmetic Operations (+, -, *, /, ^) Comparis

Sep 17, 2022
◻️ A Whitespace interpreter written in Go.

whitespace-go A Whitespace interpreter written in Go. Whitespace is a esoteric programming language made up entirely of spaces, tabs, and newlines. Th

May 18, 2022
🧠 A Brainfuck interpreter written in Go

brainfuck-go A Brainfuck interpreter written in Go. How Brainfuck works Brainfuck is an esoteric programming language designed to have the simplest co

Sep 30, 2022
A little brainfuck interpreter written in Go

Brainfuck_go_interpreter A little brainfuck interpreter written in Go from what I've done in coding game Usage $ go build brainfuck.go $ ./brainfuck P

Dec 13, 2021