# Learn You a Haskell, community fork: the same tutorial with an open source pipeline > learnyouahaskell.github.io is a community fork of Miran Lipovača's Learn You a Haskell, rebuilt as a Hakyll site whose pages are Markdown in the repository and whose changes go through pull requests. The fork exists because the original was going stale, and its licence rules out commercial reuse. **learnyouahaskell/learnyouahaskell.github.io** — A community version of the renowned "Learn You a Haskell" (LYAH) tutorials collection! - Repository: https://github.com/learnyouahaskell/learnyouahaskell.github.io - Website: https://learnyouahaskell.github.io - Stars: 622 · Forks: 74 - Language: CSS - License: NOASSERTION - Published: 2026-10-22 · Updated: 2026-10-22 · Language: en - Canonical page: https://hysenlabs.com/projects/learnyouahaskell-learnyouahaskell-github-io ## The fork exists because the original stopped keeping up learnyouahaskell.github.io is an open source fork of Learn You a Haskell, the Haskell guide by Miran Lipovača, which the README describes as the funkiest way to learn Haskell. The fork's own origin story is in the README. The creator began learning Haskell in 2021 during undergraduate studies, came across the original guide, and used it to supplement that learning. The reason for the fork, in the README's words, is that some parts are slowly becoming outdated as Haskell continues to evolve, and with the author's blessing the fork was created so the community could participate in preserving and maintaining the resource. The target reader is stated plainly: people who have programmed already but have yet to try functional programming. This is not a Haskell reference manual with a versioned API, it is a tutorial that expects a reader who already knows what a variable and a loop are. ## Content lives as Markdown so corrections become pull requests The repository layout is the mechanism behind the fork's main claim. There is a `source_md/` directory holding the Markdown sources, a `templates/` directory for the Hakyll templates, a `static/` directory for assets, and `site.hs` with `lyah-site.cabal` describing the Haskell application that renders them. The README explains the contribution path in one sentence: for the most part, you can simply edit Markdown files and open a pull request with the edits. There is also a content edit request interface, described in the TODO list as prepared on GitHub, and the README says anyone is invited to contribute either through a pull request, which it marks as preferred, or through a content edit request that is still in the pipeline. This is a meaningful difference from a published book. Corrections to a Haskell tutorial become merged text rather than a new edition, and the changelog file at the root records the history. ## Hakyll is the generator and the site is a Haskell program The site is built with Hakyll, which the README describes as a static site generator in the form of a Haskell library. The build model is slightly unusual for a documentation site and worth understanding before you change anything. With Hakyll you first build a Haskell application called `site`, and then run it to generate the HTML for the website, and the README notes that some workflows combine these steps, notably with `cabal run`. The application is described by a single package description, the `.cabal` file, and both build paths use that same description, so the README states they should produce the same result. The repository also has a `default.nix` and a `Makefile`, and the Makefile is the shortest description of the whole pipeline, since its header says the site is built from Markdown sources using Hakyll and requires either GHC and Cabal or Nix. The `all` target simply runs the generator, and the `site` target is where the compilation happens. ## Two build paths, and the Makefile shows both The README documents two ways to build, and the Makefile backs both. With Cabal, which the README calls standard and slow on the first build, you need the Haskell toolchain with GHC and Cabal installed, for example through GHCup, and then: ```bash # Update package list (first time only) cabal update # Build and run the site generator cabal run site -- build # Preview the site locally (optional) cabal run site -- watch # Then visit http://localhost:8000 ``` With Nix, which the README says is less straightforward to obtain and therefore not recommended for newcomers, you build the binary and then run the generator: ```bash # Build the site application binary with Nix nix-build # Run the site generator to build the site result/bin/site build # Preview the site locally (optional) result/bin/site watch # Then visit http://localhost:8000 ``` Nix is used in the project CI for expediency, because it provides pre-compiled binary packages for all the dependencies and significantly speeds up the first build. The Makefile mirrors this with a `nix-site` target that runs `nix-build` and then `result/bin/site build`, plus a plain `make` that generates the site through the Cabal route. Whichever route you take, the output lands in the `_site/` directory, and the `clean` target removes `_site`, `_cache`, and `_tmp`. ## The Makefile is the shortest description of the pipeline If you want to understand the project in two minutes, read the Makefile. The `all` target depends on `site` and runs `./site build`. The `site` target depends on `site.hs` and `lyah-site.cabal` and does two things, it runs `cabal build` and then copies the resulting binary with `cp $$(cabal list-bin site) ./site`, so the generator ends up as a local executable named `site`. From there the other targets are thin wrappers. `rebuild` depends on `clean` and `site` and runs `./site rebuild`, which is the Hakyll command that regenerates everything, while `watch` depends on `site` and runs `./site watch`, the mode that rebuilds on change. There is a `clean` target that removes the generated directories and the local binary, a `cleanpyc` target that finds and removes compiled Python bytecode files, and a `nix-clean` target that also removes the `result` symlink. That `cleanpyc` rule is a small clue that the site tooling reaches outside Haskell, though the README does not describe what needs it. ## The licence rules out commercial reuse of the text The licensing section is the part of this project most likely to matter to a company. The README states that the domain and repository are in no way affiliated with Miran Lipovača, and that the work is being extended and modified with his permission under the licence the original was released under, which it names as the Creative Commons Attribution-Noncommercial-ShareAlike 3.0 Unported License, along with a link to the original author's FAQ statement encouraging modifications. The repository then restates the licence at the end. Two obligations follow directly from the name of that licence. The Noncommercial clause means the text cannot be redistributed as part of a paid product or a commercial course, and the ShareAlike clause means an adapted version has to be released under the same terms. GitHub also reports the repository's licence as a custom one it cannot classify, so the LICENSE file at the root is the version to read. For a learning resource, that is a reasonable trade. For a business, it is a hard boundary. ## The open TODO list says where the project still owes work The README is upfront that this is still a work in progress, and it publishes a checklist. Refactoring the web code is not done. Making the UI more modern is not done, though the intent is stated as retaining as much of the original feel as possible. Making the content pages mobile-friendly is marked done but annotated as still needing work, and making the index page mobile-friendly is not done. Preparing the content edit request interface on GitHub is marked done, and adding exercises is not done. Updating content, described as the overall outdated parts, is not done either. The README adds that some of these points have more focused issues on GitHub. So the fork is currently better at keeping the existing prose current than at modernising the presentation, and it has no exercises yet, which is the gap you would notice first if you came to it expecting the kind of guided practice a tutorial usually pairs with. ## Conclusion This fork fits a reader who liked the original Learn You a Haskell and wants a version that keeps being corrected, or a Haskell learner who prefers editing prose through pull requests over reading a frozen book. It is the wrong tool for a company that needs to redistribute the text in a product or a paid course, because the Creative Commons Attribution-Noncommercial-ShareAlike 3.0 Unported licence forbids commercial use and requires share-alike on adaptations. Before you build on it, read the `Makefile`, since the `cabal` and `nix` paths produce the same output from the same `.cabal` file, and check the open TODO list, where updating outdated content and adding exercises are both still unchecked. ## FAQ ### How do I build the Learn You a Haskell community site locally? With Cabal, run `cabal update`, then `cabal run site -- build` to generate the site and `cabal run site -- watch` to preview it at http://localhost:8000. With Nix, run `nix-build` and then `result/bin/site build`. Either way the output ends up in the `_site/` directory. ### What licence does the Learn You a Haskell community fork use? It is licensed under the Creative Commons Attribution-Noncommercial-ShareAlike 3.0 Unported License, following the licence the original work was released under, with the original author's permission. The README also states that the domain and repository are in no way affiliated with the original author. ### Can I contribute content fixes to learnyouahaskell.github.io? Yes. The README says that for the most part you can simply edit Markdown files and open a pull request with the edits, and that anyone is invited to contribute either by opening a pull request, which is preferred, or by opening a content edit request that is still in the pipeline. There are three named maintainers, and you can ask to become one in the repository discussions. ### Why does the fork use Nix as well as Cabal? Nix provides pre-compiled binary packages for all the dependencies, which significantly speeds up the first build, and the README says this is what the project uses in its GitHub CI for expediency. Both paths rely on the same Haskell package description in the `.cabal` file, so they should produce the same result, and the README describes Nix as less straightforward to obtain and therefore not recommended for newcomers. ### What is still missing from the Learn You a Haskell community version? The TODO list in the README shows refactoring the web code, modernising the UI while retaining the original feel, making the index page mobile-friendly, adding exercises, and updating the outdated content as unchecked items. Making the content pages mobile-friendly is marked done but noted as still needing work, and the content edit request interface is marked done. ## Sources - [Issues](https://github.com/learnyouahaskell/learnyouahaskell.github.io/issues) - [learnyouahaskell/learnyouahaskell.github.io on GitHub](https://github.com/learnyouahaskell/learnyouahaskell.github.io) - [Project website](https://learnyouahaskell.github.io) - [README](https://github.com/learnyouahaskell/learnyouahaskell.github.io/blob/main/README.md) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/learnyouahaskell-learnyouahaskell-github-io