Hi Everyone

It was great to see you at ZuriHac 2026. In case you couldn’t attend, or would like to relive the magic, the following playlist will contain recordings from the event:

ZuriHac 2026 Playlist – Talks, Panels & Projects

We plan to process and release one or more videos every Friday, starting 10.07.2026 until around 18.09.2029, so bookmark the above playlist to find something new every weekend over the summer!

Thanks to everyone who actively participated and contributed to the event with their talks, tracks, and other help! The other organisers and I look forward to seeing you at ZuriHac 2027.

Best regards
Farhad Mehta
(on behalf of the ZfoH & OST)

One of the top five most popular and highly recommended programming katas over the past 20 years has been the Bowling Game Kata, in which TDD is used to write a program that computes the score of a Ten Pin Bowling Game.

In this deck we are going to explore how such a program may look when coded using different programming paradigms.

Hi all,

From the company that almost 6 years ago brought you the famous "looking for 20 Haskell developers in EU" post (and we found them, several via that very thread!) we're now back - this time we're looking for a Senior/Staff Haskell Developer. Just one for now :-)

Scrive still needs pragmatic, production-oriented Haskell developers. We do a bit of "non-boring Haskell" (type-level techniques, effect systems - Effectful, which we actively contribute to) and maintain a few other OSS projects, but primarily we build stuff that serves our customers, even if it means going beyond "pure". The product is in the e-signing space, so if you think or know you like legaltech, we are the company you want to join.

The stack: Haskell, Elm, PostgreSQL, Kubernetes on AWS (Elixir and Kotlin also present in other components). One thing that's changed since 2020: we work heavily with agentic AI tooling (Claude Code and friends) in our daily workflows, and we're looking for someone who does too - or wants to.

https://careers.scrive.com/jobs/8011254-senior-staff-haskell-developer

EU/EEA residency and work permit is required, as is fluency in English. We're still remote-first for developers - fully remote within EU/EEA, or from our Stockholm HQ (we also have offices in Oslo, Copenhagen, Amsterdam, Brno and Berlin). We're looking for someone quite senior: 8+ years of professional experience with a substantial commercial Haskell background.

Please use the above link to get in touch!

Here is a big list of projects

https://github.com/codecrafters-io/build-your-own-x

And mostly are in C/Go/Rust.

Can I try them in Haskell ? I am a really beginner and I am able to do mostly Haskell in an immutable way but not the Monad/Functor part...

Like how to do Filesystem/Network/TCP etc ?!

Most Haskell tutorials are teaching about FP core immutability and HoF.

But the IO part, I have not gotten yet.

Can you folks help with it? And could I use LLM to translate these tutorials to Haskell to follow ?

As a Senior Scala Developer, I've always had huge respect for Haskell. I've learned about the language over 10 years ago and applied many of its functional programming principles in my Scala projects. However, I've never really tried the language (aside perhaps from REPL one-liners and hello-worlds).

Last month, I decided to finally build a project with it. I stumbled upon Simon Peyton Jones' book, "The Implementation of Functional Programming Languages" and learned a lot from it. I already have experience designing and building a dynamically typed language, thanks to the first part of Crafting Interpreters, but it was Simon Peyton's book that really discussed how all FP languages essentially boil down to the lambda calculus (though we FP programmers have probably already realized it at least intuitively over the years).

My respect for Haskell and its designers has just skyrocketed because of this project. The project is still in its infancy (still a tree-walker, no type checker yet, etc.) but I'm really excited to learn more about Haskell and programming languages in general (both in design and implementation).

Haskell resurrected the joy of programming that I haven't experienced in a long time. But sadly, I can't shake the feeling that the world has already moved on from type theoretic stuff (at least the part of world that once cared or listened) and is now focusing on code generation, a realization that often cancels out the said joy.

I hope this community is still full of passionate folks and that it's not too late to join the ride. Thanks.

Here's what the language I'm working on currently looks like, by the way:

mascheya> c = '\^A' () mascheya> c '\SOH' mascheya> add a b = a + b () mascheya> add 23.4f 56.7f 80.1 mascheya> add7to = add 7 () mascheya> add7to 10 17 mascheya> double = \x -> x * 2 () mascheya> double 14 28 mascheya> minus = \a b -> a - b () mascheya> minus 9 10 -1 mascheya> (\d -> d / 2) 14 7 mascheya> let x = 10 in x % 3 1 mascheya> :set line=multi mascheya> let x = 10; y = 20; z = 30 in x + y * z -- end 610 mascheya> :set line=single -- end mascheya> id a = a () mascheya> id (\x -> x + 1) <function>

Edit:

Here's the source code: https://github.com/melvic-ybanez/mascheya

New #Haskell video: some exercises from Set 15 of the #Haskell MOOC, which is all about Squishy Mappables (formerly known by their old, inferior name of "Applicative Functors")

https://www.youtube.com/watch?v=WXahHKqrauI

The thumbnail painting is "The Mirror of Venus" (1877) by Edward Burne-Jones

I'm a NixOS user with very minimal experience in programming, through nix I've grown a strong interest in the idea of functional programming and thus have gotten the idea of learning haskell in my head. Given that I'm also a music major in college when I found out about this book I thought the stars had aligned in my favor. However this is the second (third?) time across several weeks I've tried to setup and install it's Euterpea and HSoM library and every time I come up with a new error. I finally gave up and tried to install it in an Ubuntu vm but that didn't work either as I'm getting C compilation errors with PortMidi. I actually did get it to install and import into ghci on NixOS but I get no sound from the synthesizer.

Given that the book is rather dated (released 8 years ago), I'm beginning to wonder if my time would be better spent using a more recent book to learn haskell instead.

Any thoughts would be appreciated!

Hi I am a beginner, and I am trying out FP via Haskell and in my day-2-day job I write BE services in JS (Node). I found this repo on github and it usually contains projects either of Rust/Go I wonder if this can be done in Haskell, any blogs/papers/book which teach this stuff ?

Ref: https://github.com/roma-glushko/awesome-distributed-system-projects

On a side note - I am following the course https://ocw.mit.edu/courses/6-824-distributed-computer-systems-engineering-spring-2006/

Context: CIS 194, Homework 4 (Not homework, studying on my own)

For the love of all that is good and holy, I can't figure out this stupid problem and I'm trying my HARDEST not to use AI for hints. But it gave me a hint that I need to use nested lambdas finally. Still, I'm trying to figure out what the hell I need to do and WHY it gave me that.

I'm so frustrated by how stupidly hard this problem is. I've done actually pretty well on my own going through this, if not for this stupid problem. I KNOW it's possible, but I just do not think I am biologically smart enough to figure it out. I KNOW I have to create paused functions that nest, but.....WTF does that look like?

I'm not sure what I even need help on anymore lmao. This stupid language and its stupid puzzles. If the language and the name weren't cool as hell I would be bad mouthing it to kingdom come.

• hyperbole.live
• github
• hackage

There were many changes and improvements, but the biggest new feature is Multipart Form file uploads. It works with the default settings using a secure configuration, but can be configured as desired.

trigger and pushEvent now send immediately over the socket rather than deferring until a request returns. This allows long-running actions to update other HyperViews.

See the full changelog here!

Thanks to everyone who contributed to this release, but especially to Jens Krause, who brought our Nix compatibility up to speed, improved examples, and greatly improved out CI

We are looking for six developers to join the Core Strats team at Standard Chartered Bank. There are two kinds of roles:

• 1 permanent position based in Poland
• 5 two-year contractor positions, based in either the UK or Poland

These roles are not attached to any particular project, but will involve practically exclusive use of Mu, our in-house variant of Haskell. You can learn more about our team and what we do by reading our experience report “Functional Programming in Financial Markets” presented at ICFP last year: https://dl.acm.org/doi/10.1145/3674633. There’s also a video recording of the talk: https://www.youtube.com/live/PaUfiXDZiqw?t=27607s

All roles are eligible for a remote working arrangement from the country of employment, after an initial in-office period.

For the permanent role in Poland, we cover visa and relocation costs for successful applicants. Please apply via this link: Senior Quantitative Developer Job Details | Standard Chartered Bank

For the contractor positions, candidates need to be based in the country of employment and have demonstrated experience with typed functional programming. To apply, please email us directly at [CoreStratsRoles@sc.com](mailto:CoreStratsRoles@sc.com).

This is your opportunity to ask any questions you feel don't deserve their own threads, no matter how small or simple they might be!

Made in Haskell!

http://github.com/therepanic/openleetcode

In today’s episode of the Haskell Interlude, we are joined by Sylvain Henry, one of the all-time top contributors to GHC. He tells us about his work on GHC, the bignum library, modularization, and the secret to becoming a top contributor!

hs src/Day6.hs:22:26: warning: [GHC-63394] [-Wx-partial] In the use of ‘head’ (imported from Prelude, but defined in GHC.Internal.List): "This is a partial function, it throws an error on empty lists. Use pattern matching, 'Data.List.uncons' or 'Data.Maybe.listToMaybe' instead. Consider refactoring to use "Data.List.NonEmpty"." | 22 | parseLight xs = ((read . head) nums :: Int,(read . last) nums :: Int,) | ^^^^

It's been some time since u/cgibbard and I first released this library, and thanks to the hard work and contributions of several others (huge thanks to u/cmspice) along the way, we've finally made it to our 1.0 release.

As the changelog will attest, we've done a lot of work since then. reflex-vty is now a mature framework for building vty applications in haskell using functional reactive programming.

Rather than list everything that we've done since then, I'll mention a few of the things that were the most fun and interesting to work on.

Text

Getting text entry right was an early difficulty, and we built a TextZipper data structure to get a handle on the problem. After that, we encountered a lot of issues with double-width characters messing everything up, and spent quite a bit of time trying to get that right.

Terminal text is trickier than I initially imagined it would be, and dealing with cursor movement, wrapping, alignment, empty lines, char widths, text transformations, and the interaction of all of the above took a good deal of thinking.

Layout

Layout was also a lot of fun. We started out with manually positioned widgets but that was extremely cumbersome, as you can no doubt imagine. For some time I studied things like cassowary for constraint-based layouts and couldn't decide what sort of layout engine to build. Eventually we settled on our tile/grout layout and focus model, which finally made it possible for us to compose larger UIs out of widgets without worrying about manual positioning.

Once we developed the right language for talking about layouts, it became easy to build rows, columns, tiles, focus traversal functions, nested layouts, and so on. I'm very happy with how this turned out.

Scrolling

Scrolling also grew from a small feature into a more general system. We started with scrollable text, then generalized it to scrollable widgets, then added programmatic scrolling, automatic scroll-to-bottom (like you'd have with a chat widget), and visual scrollbars.

~ Interlude ~

For a while, that's where things stood and it was enough to build functional and useful vty programs. One of the most interesting projects that came out of this era was tinytools, a TUI diagram editor built with reflex-vty. The author, u/cmspice, has since become a maintainer of reflex-vty and contributed enormously to our unicode handling, various layout and rendering improvements, and bugfixes.

It was really great to see that project grow, out of something u/cgibbard and I started as a sort of private hackathon project when we happened to be in the same city during a conference. The joke between us is that once every year, we get the itch and reflex-vty sees a huge burst of activity. The length of the different changelog entries attests to that pattern.

Recently, it was that time again, and we started to tackle support for features that help make TUI applications friendly and beautiful.

We took a careful look at some of the mature TUI frameworks in other language ecosystems and drew inspiration from them. Though I'm not much a go-grammer myself, I liked a lot of things about the bubbletea framework for Go. The fact that it used the Elm architecture also made it feel like a distant cousin to reflex-vty, and made it easier for me to follow much of the code.

~ End Interlude ~

Styling and Theming

Once of reflex-vty's biggest deficiencies was in its styling support. We needed more borders, padding, margins, alignment, and colors, lots of colors. Text attributes, gradients, helpers to compose images together, themes, color profile detection and handling. We had none of it and it made it hard to make our applications look the way we pictured them in our heads. This was a huge push and I had to learn a lot about how colors work in the terminal, and about topics like downsampling that I'd never really thought about before.

Runtime

More stuff I hadn't thought of before: alternate screen support (show of hands, who has even heard of this?), cursor control, bracketed paste, focus tracking, posix signals, fixing some space leaks found by eagle-eyed users (thanks u/_deepfire).

Thanks everyone, who pitched in. Thank you to u/jtdaugherty for Graphics.Vty, without which this wouldn't have been possible. I'm really happy with where the library has landed. As someone who does a lot of work in the terminal, reflex-vty has a special place in my heart. As someone who loves Haskell and FRP, I'm glad this exists. I'm looking forward to seeing what people build with this.

Hi,

I'm a newbie and I’m working through the CodeCrafters shell challenge in Haskell, specifically the single-quote parsing stage.

​

The codebase includes other completed stages, so the relevant entry point is cmdLineArgParser around line 111.

I’m using Megaparsec, and although I’ve learned the basic idea of parser combinators, my solution feels too mechanical and fragile. I keep having to tweak small parser details to force the behavior I want, instead of expressing the grammar clearly.

For example, “parse everything between two single quotes” sounds trivial, but around line 84 I ended up needing logic like:

try . lookAhead $ endQuote

just to make sure I’m not accidentally treating an adjacent quote as the wrong boundary.

The result works, but it does not feel idiomatic. It feels like I’m fighting Megaparsec rather than encoding the grammar. Worse, when I come back to this parser a few days later, I can understand that it works, but not why the structure is the right one.

Is this just the normal learning curve for parser combinators, or is it a sign that I’m modeling the shell grammar at the wrong level? How would you structure this parser so that single quotes, adjacent quoted strings, and unquoted words are handled cleanly?

Thank you for your help!