Scheme based powerful lisp interpreter in JavaScript
See the code
LIPS is a powerful Scheme-based, Lisp language written in JavaScript. It is based on the Scheme dialect of lisp and the R5RS/R7RS specifications. It has extensions to make it easier to interact with JavaScript and extend the language. It works both in the browser and with Node.js.
The aim of the project is to support full R7RS specification and be compatible with Scheme programming language.
The name is a recursive acronym which stands for LIPS Is Pretty Simple.
To install you can use npm, which comes with Node.js or any other package
manager (e.g.: yarn, bun, or pnpm)
The easiet way to install and use LIPS is via npx command (part of NPM):
npx lips@beta
Or you can install it:
npm install -g lips@beta
You can also install it as part of your Node project.
You need to include the javascript file in script tag inside your HTML.
You an grag the main file from jsDelivr:
<script src="https://cdn.jsdelivr.net/npm/lips@beta/dist/lips.min.js"></script>
You can also run the REPL on any page while you learn Scheme using the bookmarklet:
https://github.com/jcubic/lips/blob/master/lib/js/bookmark.js
Create any link in your bookmarks, edit it and copy-paste the content of that file. After you click on the link it will create the REPL at the bottom of the page. (NOTE: It may not work on every page because of content security policy; e.g. google.com or gihub.com)
If you have trouble with creating the bookmarklet, you can open LISP Scheme home page where you can find a link that you can drag to your bookmarks.
The simplest way is to include the lips code in the script tag:
<script type="text/x-scheme" bootstrap>
(let ((what "world")
(greet "hello"))
(display (string-append greet " " what)))
</script>
or use the src attribute:
<script type="text/x-scheme" bootstrap src="example.scm"></script>
You can use the REPL by typing:
lips
Or create a script using shebang:
#!/usr/bin/env -S lips
(print "Hello, world!")
If you save this into hello.scm and make it executable:
chmod a+x hello.scm
You can execute the script:
./hello.scm
it should print Hello, world!.
Big part of LIPS is written in LIPS itself, but to use full power of LIPS you need
to load those additional Scheme files. The easiest way is to add bootstrap attribute
on first script tag with text/x-scheme type. By default, it will use CDN from
jsdelivr. To load each file using builtin load function
(that will fetch the file using AJAX and evaluate it).
<script src="https://cdn.jsdelivr.net/npm/lips@beta/dist/lips.min.js" bootstrap></script>
You can also specify the path where LIPS should search for standard library.
<script src="https://cdn.jsdelivr.net/npm/lips@beta/dist/lips.min.js"
bootstrap="https://cdn.jsdelivr.net/npm/lips@beta/dist/std.xcb">
</script>
You can use bootstrap="./std.xcb" if there is std.xcb file in local directory.
You can also bootstrap with std.scm or std.min.scm but xcb file is the fastest,
because it's already parsed and compiled into binary format.
var {exec} = require('lips'); // node
// or
var {exec} = lips; // browser
exec(string).then(function(results) {
results.forEach(function(result) {
console.log(result.toString());
});
});
When running exec you will also need to bootstrap the language and loaded files from /lib/ directory.
Documentation about beta version can be found in Wiki.
NOTE: Executable don't require bootstrapping lib files.
If you install lips globally with:
npm install -g lips@beta
you can run the interpreter from the terminal:
You can also run code in a string with:
lips -c '(let ((what "World")) (display (string-append "Hello " what)))'
and you can run a file using:
cat > foo.scm <<EOF
(let ((what "World"))
(display (string-append "Hello " what))
(newline))
EOF
lips foo.scm
You can also write executable files that use lips using shebang (SRFI-22)
cat foo.scm
#!/usr/bin/env lips
(let ((what "World"))
(display (string-append "Hello " what))
(newline))
chmod a+x foo.scm
./foo.scm
Executables also return a S-Expression according to SRFI-176 use lips --version or lips -V.
Because LIPS is tree walking interpreter, sometimes it may be slow. Especially if you want to process long arrays and use callback function. If the array is quite large each piece of code inside the callback may slow down the processing. For example see:
script reference.scm
That generates reference documentation for all builtin functions and macros.
The slow part is (names.sort name-compare) (Array::sort) that take quite time to calculate,
because the array with functions and macros is quite large. If you came into performance issue,
you can write the part of the code in JavaScript. If you want to do this in LIPS Scheme you can use
something like this:
(let ((fn (self.eval "(function(a, b) {
/* any complex code in JS */
return a.localeCompare(b);
})")))
(arr.sort fn))
Another example of slow performance is using LIPS with React, the more code you put into components the slower the app will become.
Examples:
The issue with performance is tracked in #197.
| description | spec |
|---|---|
| Feature-based conditional expansion construct | SRFI-0 |
| Homogeneous numeric vector datatypes | SRFI-4 |
| Basic String Ports | SRFI-6 |
| Running Scheme Scripts on Unix | SRFI-22 |
| Error reporting mechanism | SRFI-23 |
| Basic Format Strings | SRFI-28 |
| Basic Syntax-rules Extensions | SRFI-46 |
| An interface to access environment variables | SRFI-98 |
| Syntax parameters | SRFI-139 |
| Custom macro transformers | SRFI-147 |
| Version flag | SRFI-176 |
| Command line | SRFI-193 |
| Mixing groups of definitions with expressions within bodies | SRFI-251 |
You can load the SRFI with special syntax that start with @lips
which points to root LIPS directory:
(load "@lips/lib/srfi/<number>.scm")
They should be loaded as R7RS libraries in final 1.0.0 version
| description | spec |
|---|---|
| List Library | SRFI-1 |
AND-LET*: an AND with local bindings, a guarded LET* special form | SRFI-2 |
| receive: Binding to multiple values | SRFI-8 |
#, external form | SRFI-10 |
| Notation for Specializing Parameters without Currying | SRFI-26 |
| Basic hash tables | SRFI-69 |
| Boxes | SRFI-111 |
| Syntactic combiners for binary predicates | SRFI-156 |
| Multiple-value boxes | SRFI-195 |
| Pipeline Operators | SRFI-197 |
| Procedures and Syntax for Multiple Values | SRFI-210 |
| Evaluating expressions in an unspecified order | SRFI-236 |
| Destructuring Lists | SRFI 239 |
| Uninterned Symbols | SRFI 258 |
in Web (e.g. in Web REPL) you can also use full URL:
(load "https://cdn.jsdelivr.net/npm/lips@beta/lib/srfi/<NUMBER>.scm")
import/export/define-library).syntax-rules (ignore limitations of current approach).
syntax-rules).I'm working on version 1.0. If you find any bugs, you can help by reporting them. If you have some Scheme code that doesn't work (note about the limitations) don't hesitate to report an issue.
You can also propose a feature or improvement to the library, it doesn't always have to be defects.
If you enjoy the library, you can write about it on a blog post and share information about it or write on Social Media. Don't forget to link to the project website (it's good for SEO).
Of course, if you like, you can also contribute with code, but there are way easier ways to help.
I would also love to see if you use the library; I may even share the links of projects that use it.
fetch polyfill use unfetch by Jason Miller.init function uses ContentLoaded.ucs2decode function taken from punycode.js by Mathias Bynens.Special thanks:
Thanks to Algolia DocSearch for providing free search on the LIPS website.
Released under MIT license
Copyright (c) 2018-2026 Jakub T. Jankiewicz
Overall
Maintained
Code review
npm
Latest release
Releases this year
472 followers · starred Dec 2020
120 followers · starred Dec 2020
8 followers · starred Aug 2026
185 followers · starred Aug 2026
Scheme based powerful lisp interpreter in JavaScript
See the code
LIPS is a powerful Scheme-based, Lisp language written in JavaScript. It is based on the Scheme dialect of lisp and the R5RS/R7RS specifications. It has extensions to make it easier to interact with JavaScript and extend the language. It works both in the browser and with Node.js.
The aim of the project is to support full R7RS specification and be compatible with Scheme programming language.
The name is a recursive acronym which stands for LIPS Is Pretty Simple.
To install you can use npm, which comes with Node.js or any other package
manager (e.g.: yarn, bun, or pnpm)
The easiet way to install and use LIPS is via npx command (part of NPM):
npx lips@beta
Or you can install it:
npm install -g lips@beta
You can also install it as part of your Node project.
You need to include the javascript file in script tag inside your HTML.
You an grag the main file from jsDelivr:
<script src="https://cdn.jsdelivr.net/npm/lips@beta/dist/lips.min.js"></script>
You can also run the REPL on any page while you learn Scheme using the bookmarklet:
https://github.com/jcubic/lips/blob/master/lib/js/bookmark.js
Create any link in your bookmarks, edit it and copy-paste the content of that file. After you click on the link it will create the REPL at the bottom of the page. (NOTE: It may not work on every page because of content security policy; e.g. google.com or gihub.com)
If you have trouble with creating the bookmarklet, you can open LISP Scheme home page where you can find a link that you can drag to your bookmarks.
The simplest way is to include the lips code in the script tag:
<script type="text/x-scheme" bootstrap>
(let ((what "world")
(greet "hello"))
(display (string-append greet " " what)))
</script>
or use the src attribute:
<script type="text/x-scheme" bootstrap src="example.scm"></script>
You can use the REPL by typing:
lips
Or create a script using shebang:
#!/usr/bin/env -S lips
(print "Hello, world!")
If you save this into hello.scm and make it executable:
chmod a+x hello.scm
You can execute the script:
./hello.scm
it should print Hello, world!.
Big part of LIPS is written in LIPS itself, but to use full power of LIPS you need
to load those additional Scheme files. The easiest way is to add bootstrap attribute
on first script tag with text/x-scheme type. By default, it will use CDN from
jsdelivr. To load each file using builtin load function
(that will fetch the file using AJAX and evaluate it).
<script src="https://cdn.jsdelivr.net/npm/lips@beta/dist/lips.min.js" bootstrap></script>
You can also specify the path where LIPS should search for standard library.
<script src="https://cdn.jsdelivr.net/npm/lips@beta/dist/lips.min.js"
bootstrap="https://cdn.jsdelivr.net/npm/lips@beta/dist/std.xcb">
</script>
You can use bootstrap="./std.xcb" if there is std.xcb file in local directory.
You can also bootstrap with std.scm or std.min.scm but xcb file is the fastest,
because it's already parsed and compiled into binary format.
var {exec} = require('lips'); // node
// or
var {exec} = lips; // browser
exec(string).then(function(results) {
results.forEach(function(result) {
console.log(result.toString());
});
});
When running exec you will also need to bootstrap the language and loaded files from /lib/ directory.
Documentation about beta version can be found in Wiki.
NOTE: Executable don't require bootstrapping lib files.
If you install lips globally with:
npm install -g lips@beta
you can run the interpreter from the terminal:
You can also run code in a string with:
lips -c '(let ((what "World")) (display (string-append "Hello " what)))'
and you can run a file using:
cat > foo.scm <<EOF
(let ((what "World"))
(display (string-append "Hello " what))
(newline))
EOF
lips foo.scm
You can also write executable files that use lips using shebang (SRFI-22)
cat foo.scm
#!/usr/bin/env lips
(let ((what "World"))
(display (string-append "Hello " what))
(newline))
chmod a+x foo.scm
./foo.scm
Executables also return a S-Expression according to SRFI-176 use lips --version or lips -V.
Because LIPS is tree walking interpreter, sometimes it may be slow. Especially if you want to process long arrays and use callback function. If the array is quite large each piece of code inside the callback may slow down the processing. For example see:
script reference.scm
That generates reference documentation for all builtin functions and macros.
The slow part is (names.sort name-compare) (Array::sort) that take quite time to calculate,
because the array with functions and macros is quite large. If you came into performance issue,
you can write the part of the code in JavaScript. If you want to do this in LIPS Scheme you can use
something like this:
(let ((fn (self.eval "(function(a, b) {
/* any complex code in JS */
return a.localeCompare(b);
})")))
(arr.sort fn))
Another example of slow performance is using LIPS with React, the more code you put into components the slower the app will become.
Examples:
The issue with performance is tracked in #197.
| description | spec |
|---|---|
| Feature-based conditional expansion construct | SRFI-0 |
| Homogeneous numeric vector datatypes | SRFI-4 |
| Basic String Ports | SRFI-6 |
| Running Scheme Scripts on Unix | SRFI-22 |
| Error reporting mechanism | SRFI-23 |
| Basic Format Strings | SRFI-28 |
| Basic Syntax-rules Extensions | SRFI-46 |
| An interface to access environment variables | SRFI-98 |
| Syntax parameters | SRFI-139 |
| Custom macro transformers | SRFI-147 |
| Version flag | SRFI-176 |
| Command line | SRFI-193 |
| Mixing groups of definitions with expressions within bodies | SRFI-251 |
You can load the SRFI with special syntax that start with @lips
which points to root LIPS directory:
(load "@lips/lib/srfi/<number>.scm")
They should be loaded as R7RS libraries in final 1.0.0 version
| description | spec |
|---|---|
| List Library | SRFI-1 |
AND-LET*: an AND with local bindings, a guarded LET* special form | SRFI-2 |
| receive: Binding to multiple values | SRFI-8 |
#, external form | SRFI-10 |
| Notation for Specializing Parameters without Currying | SRFI-26 |
| Basic hash tables | SRFI-69 |
| Boxes | SRFI-111 |
| Syntactic combiners for binary predicates | SRFI-156 |
| Multiple-value boxes | SRFI-195 |
| Pipeline Operators | SRFI-197 |
| Procedures and Syntax for Multiple Values | SRFI-210 |
| Evaluating expressions in an unspecified order | SRFI-236 |
| Destructuring Lists | SRFI 239 |
| Uninterned Symbols | SRFI 258 |
in Web (e.g. in Web REPL) you can also use full URL:
(load "https://cdn.jsdelivr.net/npm/lips@beta/lib/srfi/<NUMBER>.scm")
import/export/define-library).syntax-rules (ignore limitations of current approach).
syntax-rules).I'm working on version 1.0. If you find any bugs, you can help by reporting them. If you have some Scheme code that doesn't work (note about the limitations) don't hesitate to report an issue.
You can also propose a feature or improvement to the library, it doesn't always have to be defects.
If you enjoy the library, you can write about it on a blog post and share information about it or write on Social Media. Don't forget to link to the project website (it's good for SEO).
Of course, if you like, you can also contribute with code, but there are way easier ways to help.
I would also love to see if you use the library; I may even share the links of projects that use it.
fetch polyfill use unfetch by Jason Miller.init function uses ContentLoaded.ucs2decode function taken from punycode.js by Mathias Bynens.Special thanks:
Thanks to Algolia DocSearch for providing free search on the LIPS website.
Released under MIT license
Copyright (c) 2018-2026 Jakub T. Jankiewicz
Overall
Maintained
Code review
npm
Latest release
Releases this year
472 followers · starred Dec 2020
120 followers · starred Dec 2020
8 followers · starred Aug 2026
185 followers · starred Aug 2026