The Technical Leadership Committee is the body behind the Haskell Foundation’s technical vision. The committee is responsible for expressing a technical vision for the Haskell community and allocating the Haskell Foundation’s resources towards achieving this vision.
If you wish to contact the Technical Leadership Committee, you may do so via technical-leadership@haskell.foundation.
Julian started his open source journey as a Gentoo Linux developer, working with large teams of distributed volunteers. He picked up Haskell when a friend told him about this strange new language that would revolutionize all of software engineering. This spark turned into a mission to fix tooling around Haskell (e.g. GHCup) and contribute to the larger ecosystem. His professional journey has taken him across fintech startups (Capital Match), banks (Standard Chartered Bank) and software labs (IOG).
Julian believes in open source, human collaboration and unix principles. He draws his passion from the beauty of the craft and the need to support and exercise good engineering.
Simon worked on GHC full time from about 1998 to 2013, and sporadically since then. He is the main author of the runtime system, the code generator, and various other parts of the compiler. He is the author of the O’Reilly book “Parallel and Concurrent Programming in Haskell”. In 2013 he moved to Facebook (now Meta) where he led the team that built the largest ever production Haskell deployment, Sigma, which was a platform for combating abuse on Facebook, Instagram and WhatsApp. While at Meta he also led the team that built Glean, a system for collecting and querying information about source code at scale; Glean is open-source and is still in use as a core part of Meta’s developer tooling infrastructure. He left Meta in February 2025 and nowadays he spends his time mostly riding his bike and hacking on things that he finds interesting.
Josh has been using Haskell at H-E-B since 2018 to build resilient, long-lived systems for the supply chain. He is a firm believer in keeping software open and collaborative, and his desire to push Haskell in industry is evidenced by his ongoing open-source work (e.g. Arbiter). In addition to programming, Josh likes to play piano and produce his own music.
Rodrigo is a compiler engineer working at Well-Typed on GHC, the Haskell Debugger, and other open-source core ecosystem tools full-time (besides more Haskell projects on his free time). Rodrigo is also passionate about teaching and academia and is currently an invited professor at FCUL in Lisbon; his work on the interaction of laziness and linearity was recently published at POPL, and he’s interested in doing research when time permits. In his additional free time, he is preparing to train for a triathlon.
Come back soon!
We believe that Haskell is awesome and that it can provide unique value to everyone, because it sits at an interesting intersection between human craftsmanship and machine automation:
There may be better languages for formal verification or for vibecoding, but there’s no better language for “human in the loop”. Haskell is where we maintain control of our work, build institutional knowledge and ship responsibly.
We’re driven to improve Haskell for everyone:
Imagine Haskell had the iteration speed of golang, the debugging capabilities of C# and the onboarding experience of rust. And all that while providing stronger guarantees and better performance!
Modern workflows require fast iteration times: compilation, interactive repl, remote dependency caching, CI and test integration. All of this affects both human and machine workflows.
While Haskell scales well in terms of code complexity… it doesn’t scale well in terms of build times. As an example, GHC’s own CI has turnaround times of 6 hours. We want to bring them down to 2.
Instead of helplessly dumping logs and binaries into LLM chats, we envision deterministic tools that allow precise and ergonomic enquiries:
And all of that in your editor/IDE as well as through powerful CLI and scripting interfaces, the latter enabling power users as well as LLM-driven debugging (natively, without requiring any custom adapters like MCP).
Debugging must be fun again, without littering Debug.Trace.trace all over
your codebase.
Documentation and interactive exploration will assist newcomers in understanding all caveats of laziness and GHC and should clearly explain how to leverage these tools.
In these times of low frustration tolerance, we are going to build the best onboarding experience in the programming language ecosystem, because it is the ultimate benchmark for developer experience as a whole.
This can only be done if we commit to unix principles, which we summarize as:
Documentation should be a joy to read, written by humans, for humans.
Security and trust don’t get established by accident. Once trust is lost, it’s often irrecoverably lost.
To protect our community assets and reputation, we need to:
We should further support attempts to utilize or extend the strengths of the Haskell language to boost practical applications of secure design and architecture, such as Information Flow Control or Mandatory Access Control. We’re also monitoring the efforts of dependent types and liquidhaskell.
What if we could compile Haskell software that’s 10 years old with the latest GHC, without any source code changes?
While this might seem like an impossible goal to achieve… embarking on that journey is going to get us closer to a robust, stable and predictable ecosystem anyway.
The questions we need to answer along the way are:
Not only requires this investment in GHC and core tooling, but also potentially support community efforts to maintain stable package sets or coordinate ecosystem upgrades, make cabal more ergonomic for complex use cases, spearhead and support stability policies and gather data about what parts of the ecosystem cause churn.
We want Haskell to not only be a choice for fast moving startups, but also for large or conservative companies that do not want their workflows or software stacks disrupted. Stability will benefit both of these types of users, reduce cost and friction and build a reputation for Haskell as a modern language with a predictable ecosystem.
All of the above is an attempt to support the Haskell open source ecosystem that we love. We are committed to open source, its values and the social aspect of it. Collaboration is how we engage with and inspire each other.
We want to enable all the maintainers and volunteers who keep this ecosystem alive, many of them unknown, doing their part on a Saturday evening at the other end of the world.
We code because we love to ship products. But we also code, because we want to socialize, meet people and have a good time. We’re committed to both of these values.