Open-source project
purescript/purescript avatar
purescript/purescript

purescript: a small language, an 0.15 version line, and a Stack-only Makefile

A strongly-typed language that compiles to JavaScript

8,923 stars574 forksHaskellNOASSERTION

At a glance

What is it?
A strongly typed language with expressive types that compiles to JavaScript and is written in Haskell, where the whole build goes through Stack with a locked resolver, the changelog is assembled from fragments by a Haskell script, a dead-code configuration sits in the root, and every recent release is still on the 0.15 line.
Who is it for?
purescript suits someone who wants a real static type system running on the JavaScript runtime and is willing to learn a small language rather than configure a large toolchain. It does not suit you if you need the breadth of the TypeScript ecosystem, and the 0.15 version line means a version number will not tell you which features you have.
Can I use it commercially?
Check first. The repository uses a licence we do not classify automatically, so read its LICENSE file before any commercial use.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Haskell, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • purescript/purescript8,923 ★ · +9
Star history
Repository2026-09-222026-11-15
purescript/purescript8.9k8.9k

9 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

It calls itself small, and that is a design position

The self-description is one sentence and every word in it is doing work. PureScript is described as a small, strongly typed programming language with expressive types that compiles to JavaScript, written in and inspired by Haskell. Small and expressive types sit together deliberately here. A small surface is what keeps a type system learnable, and it distinguishes this from the pattern of a language with a modest core wrapped in a large framework ecosystem you must also learn. The Haskell clause applies twice, once to what the compiler is written in and once to where the ideas came from, and it should be read as inspiration rather than as a claim that every Haskell feature exists here. The output target is JavaScript, which is the other half of the pitch and the reason the language sits where it does.

Every Makefile target routes through Stack

The build file is worth reading because it shows what a contributor actually types. It sets a binary directory, a build directory, a package name and an executable target, then defines its Stack invocation as the stack command with the stack yaml file passed through an environment variable. From there the targets are thin wrappers. Building the package, installing the executables to the Stack path, opening a REPL on the library, and running the tests are each a single command, with the fast flag used for tests and for the run target that builds and then executes the compiler:

make
exe_target = purs
make
build: ## Build the package.
	$(stack) build $(package)
make
test: ## Run the tests.
	$(stack) test --fast $(package)

The repository also carries a cabal project file, a cabal package description and a Setup module, so Cabal is supported for packaging while the daily targets all use Stack with a locked resolver.

A bare make prints documentation instead of building

The default goal is set to help rather than to build, and the help target works by grepping the makefile for targets that carry a trailing comment, then printing them with colour. The practical effect is that someone who clones the repository and types make gets a list of what the project can do instead of a silent no-op or an unexpected compilation. The clean target is similarly thorough, removing the binary directory, the build directory, the Stack work directory, the Cabal dist-newstyle directory, and the REPL and test module directories. Those last two are worth noting: they are created by other tools during a session, so a clean target that did not know about them would leave artefacts behind and change the behaviour of the next build.

The changelog is assembled from per-change fragments

Changelog management in this repository is a directory and a script rather than one document. There is a directory of changelog fragments, a combined changelog file at the root, and a Haskell script named for updating the changelog, alongside a release guide. That arrangement is familiar to anyone who has used a changeset-style workflow, and the reason is conflict avoidance. A single changelog file is a file that every contributor edits, so two changes landing in the same week collide in the same lines. One small file per change means the merge conflicts happen on files nobody else is touching. The cost is that the readable changelog only exists after the script runs, so the fragments are the source of truth and the assembled document is a build product.

A versioning policy file sits next to three 0.15 releases

The root of the repository carries a versioning policy document, which is unusual enough to be worth reading before you rely on any version number. The recent releases are all on the same line: v0.15.16-8 from October 2025, v0.15.16 from March 2026, and v0.15.17-0 from June 2026. Two of the three carry a suffix. So the language has stayed within 0.15 across all of them, and the last push to the repository was 21 October 2026. What that means for a reader is concrete: a PureScript version number tells you the language generation rather than how recent the tool is, and the suffix is the signal that matters when you are deciding whether something is safe to depend on.

Dead-code detection is configured, not optional

Two configuration files in the root treat the compiler the way you would treat a codebase with a large surface area. One configures a dead-code detector, which is a tool that finds declarations nothing references, and another configures a Haskell linter, with an .hspec file and a license-generator directory alongside them. The makefile's bin/hlint rule runs an install script from the continuous integration directory and then touches the result into the binary directory so make does not reinstall it every time. For a compiler project the dead-code configuration is the notable one, because it sets a bar that a lot of Haskell projects do not set for themselves: code that nothing reaches is treated as a problem to be removed rather than as harmless residue.

Source maps and glob tests are shell scripts in the root

Two shell scripts sit at the top level alongside the build files, and between them they answer two questions a compiler user would otherwise have to ask elsewhere. One, get-source-maps.sh, is named for source maps, which matter because the compiler's output is JavaScript. The other is glob-test.sh. Both being shell scripts rather than Haskell is a small reminder of what this tool is: a Haskell program that produces JavaScript, with the surrounding shell tooling arranged to make that output usable in the browser.

Editorial conclusion

purescript suits someone who wants a real static type system running on the JavaScript runtime and is willing to learn a small language rather than configure a large toolchain. It does not suit you if you need the breadth of the TypeScript ecosystem, and the 0.15 version line means a version number will not tell you which features you have. Before committing, read the versioning policy, check the package index for the libraries you actually need, and look at how the compiler's own build is configured, since that is the shape of the toolchain you inherit.

Frequently asked questions

What is purescript?

A small, strongly typed programming language with expressive types that compiles to JavaScript, written in and inspired by Haskell. It is distributed on Hackage, has its own site, book, documentation set, an online try-it environment and a package index called Pursuit.

What is PureScript used for?

Writing JavaScript applications with a compile-time type system rather than type annotations. The compiler emits JavaScript, and packages are distributed through the Pursuit package index. The compiler itself is the purs executable, built through Stack.

Is purescript dead?

The repository metadata does not suggest it. Recent releases are v0.15.16-8, v0.15.16 and v0.15.17-0, dated October 2025, March 2026 and June 2026, and the last push to the repository was 21 October 2026. The project maintains a community code of conduct covering its main discussion spaces and a versioning policy document.

Is purescript lazy?

The front page does not address evaluation strategy, so the repository does not answer that question. What it does state is that the language is small and strongly typed with expressive types, compiles to JavaScript, and is written in and inspired by Haskell.

What are the differences between TypeScript and PureScript?

The repository does not publish a comparison with TypeScript. What it states about itself is that it is a small, strongly typed language with expressive types, that it compiles to JavaScript, and that it is written in and inspired by Haskell. For a comparison you would need sources beyond this project.

Official sources

  1. Issues
  2. Project website
  3. purescript/purescript on GitHub
  4. README
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/purescript-purescript.svg)](https://hysenlabs.com/projects/purescript-purescript)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/purescript-purescript.svg)](https://hysenlabs.com/projects/purescript-purescript)

Was this useful?