# OpenGOAL: a GOAL compiler and decompiler that runs Jak and Daxter natively on x86-64

> OpenGOAL decompiles Naughty Dog's GOAL code and recompiles it for x86-64 instead of emulating the PS2. Jak 1 is finished, Jak 2 is in beta, and Jak 3 still has work left.

**open-goal/jak-project** — Reviving the language that brought us the Jak & Daxter Series

- Repository: https://github.com/open-goal/jak-project
- Website: https://opengoal.dev
- Stars: 3,531 · Forks: 235
- Language: Common Lisp
- License: ISC
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/open-goal-jak-project

## What OpenGOAL solves, and who it is actually for

The Jak and Daxter trilogy was written in GOAL, a custom LISP dialect Naughty Dog built in-house. Over 98% of the games, according to the README, were written in it. That makes ordinary emulation the easy path and a native port the hard one: the game logic is not C that a modern compiler can swallow, it is a language whose compiler no longer exists in usable form. OpenGOAL's answer is to decompile the original game code into human-readable GOAL, write a new GOAL compiler that targets x86-64, and rebuild the game from that source.

The project is explicit that its GitHub repositories are for development and issue tracking, and that most of what is there concerns setting up the project for development rather than playing. That split matters. Two audiences exist: players, who are pointed at a setup video and the opengoal.dev documentation, and contributors, who read the rest of the README and build from source. If you only want to play, the repository is the wrong door.

One constraint is not negotiable. The README states that OpenGOAL includes no assets from the original games, so you must provide your own legitimately obtained PS2 copy. It supports every retail PAL, NTSC and NTSC-J build, including Greatest Hits, but not the later PS3, PS4 or PS5 releases.

## How the decompiler and the GOAL compiler fit together

The pipeline has four stages, and the README names them: build the C++ tools, extract assets from the game, build the game, run the game. The interesting part is the middle.

A decompiler processes GOAL code and unpacks game assets. It is designed specifically for the output of the original GOAL compiler, which is why it can work at all: the input is not arbitrary machine code but a known compiler's product. The decompiler cannot always infer types on its own, so the team manually specifies function types and locations where they believe the original code had type casts, iterating until decompilation succeeds. The output is then cleaned up by hand, with comments and formatting adjusted, and saved under goal_src/. That manual step is the honest cost of the approach, and the README does not pretend otherwise.

Because the decompiler targets one specific compiler's output, correct casts often produce code that can be fed straight back into a compiler and works. The README notes this is continually tested as part of the unit tests. From there the new GOAL compiler emits x86-64. The stated objectives are a native application with high performance, not emulated, interpreted or transpiled, with compiler performance around that of unoptimized C. The compiler also preserves live modification of code while the game runs, a feature of the original toolchain that the project keeps even though porting alone would not require it. Supporting modifications, so that edits do not break everything else, is a separate stated objective.

## Setting up a development environment and extracting assets

The README routes OS setup through per-platform documents for Windows, Linux, macOS and Docker, and editor setup through notes for Visual Studio, Visual Studio Code and Zed. The build itself is driven by a Taskfile. The first real step is telling the toolchain which game and which version you are working with; the README gives this example for the black label version of Jak 1.

```sh
task set-game-jak1
task set-decomp-ntscv1 # or for example for PAL, `task set-decomp-pal`
```

After that, extract your ISO contents into the matching folder under iso_data/, which for Jak 1 is iso_data/jak1. The README then continues into the compiler run and the game launch, and documents connecting a REPL to the running game and running without auto-booting. Those last two are the parts that matter for iteration: the REPL is how you modify code while the game is live, which is the same workflow the original GOAL toolchain offered.

Note the shape of the workflow. You are not installing a launcher. You are building C++ tools, unpacking a disc image, compiling GOAL source, and then running the result. Run `task --list` to see the other game and region options.

## Where OpenGOAL is the wrong tool

The clearest failure mode is legal and practical at once: without your own retail PS2 copy, the project cannot help you, because it ships no assets. The README's warning is blunt about this, and it also excludes the PS3, PS4 and PS5 re-releases, so owning one of those does not qualify.

Platform support is narrower than the phrase "on PC" suggests. The README states x86_64 on Windows, Linux and macOS, with macOS running through Rosetta translation. That is not a native arm64 build. If you are on Apple Silicon and expect native performance, the documented path is translation, and the README does not describe an alternative. There are no plans to ever make a mobile release, so Android and iOS are out permanently rather than pending.

Completion is uneven across the trilogy. Jak 1 has been considered polished and complete for years. Jak 2 is called beta because of a few known issues, though the README expects it to feel essentially complete to a casual player. Jak 3 has a good amount of work left to do. Anyone whose interest is Jak 3 should read that sentence before building anything. Finally, if you want a save-state, a rewind buffer or per-frame texture swapping, that is emulator territory; OpenGOAL is a recompiled native application and its objectives do not include those features.

## OpenGOAL against PCSX2 and the original hardware

The obvious alternative is an emulator such as PCSX2. The difference is architectural, not a matter of polish. An emulator executes the original PS2 binaries, translating MIPS instructions and modelling the console's hardware as it goes. OpenGOAL throws the binaries away: it decompiles the GOAL source, recompiles it for x86-64, and repacks assets into a format the port uses. The README's stated aim is that the result should not be emulated, interpreted or transpiled.

That choice buys different things. An emulator runs the disc as shipped and inherits every behaviour of the original, including its bugs and its timing. OpenGOAL runs code that humans have read, annotated and can edit, with a live REPL attached to the running game, which is why modification support is a first-class objective rather than an afterthought. It also means coverage depends on how far the decompilation has progressed for each title, which is exactly why Jak 3 lags. An emulator has no such gradient.

The original hardware remains the reference point for anyone who wants the game as it shipped on a CRT. OpenGOAL is for people who want the same game logic running as a native x86-64 application and are willing to accept the state of each port as documented.

## Maintenance, releases and the licence

The repository is not archived, and the last push was on 2026-09-22, one day before this was written, so development is current. Releases are frequent and incremental: v0.3.5 on 2026-07-04, v0.3.6 on 2026-08-25, and v0.3.8 on 2026-09-20. The jump from v0.3.6 to v0.3.8 in the listed releases suggests the changelog, not this list, is the place to check for anything in between.

Upgrade cost is the real question for a contributor. Because the decompiled code lives in goal_src/ and the compiler is rebuilt alongside it, pulling a new revision means recompiling rather than swapping a binary. The README's build sequence, from C++ tools through asset extraction to the compiler and launch, is the loop you repeat. Local edits to decompiled files can conflict with upstream changes, which is the trade-off the project accepts in exchange for keeping the source editable and the game modifiable.

The licence is ISC, a permissive licence. That covers the project's own code. It does not cover the game: the README states plainly that OpenGOAL includes no assets from the original games and that you must supply your own legitimately obtained copy. Keep the two separate, and treat the question of what you may do with extracted or modified assets as one for your own legal advice rather than something the ISC licence settles.

## Conclusion

OpenGOAL is for people who own a retail PS2 copy of Jak 1, 2 or 3 and want a native x86-64 build rather than an emulator, and for developers willing to run the Taskfile-based build. It is not for anyone without a legally purchased disc, and not for mobile: the README states there are no plans to ever make a mobile release. Before committing, check the Current Status list for your game, since Jak 3 still has a good amount of work left, and confirm that your disc is a retail PAL, NTSC or NTSC-J build rather than a later PS3, PS4 or PS5 release, which the project does not support.

## FAQ

### Do I need my own copy of Jak and Daxter to use OpenGOAL?

Yes. The README warns that the project includes no assets from the original games and that you must provide your own legitimately obtained PS2 copy. It supports every retail PAL, NTSC and NTSC-J build, including Greatest Hits, but not the later PS3, PS4 or PS5 releases.

### Which platforms does OpenGOAL support?

The README states x86_64 on Windows, Linux and macOS, with macOS running via Rosetta translation. It also states there are no plans to ever make a mobile release.

### Is OpenGOAL finished for all three Jak games?

No. Jak 1 has been considered polished and complete for years, Jak 2 is called beta due to a few known issues, and Jak 3 has a good amount of work left to do.

### How do I tell the build which game and region I am using?

The README shows Taskfile commands for this, for example `task set-game-jak1` followed by `task set-decomp-ntscv1`, or `task set-decomp-pal` for the PAL version. Running `task --list` shows the other available options.

## Sources

- [License: ISC](https://github.com/open-goal/jak-project/blob/master/LICENSE)
- [open-goal/jak-project on GitHub](https://github.com/open-goal/jak-project)
- [Project website](https://opengoal.dev)
- [README](https://github.com/open-goal/jak-project/blob/master/README.md)
- [Releases](https://github.com/open-goal/jak-project/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/open-goal-jak-project