haskell Tweag Blog

cooked-validators is a Haskell library to write offchain code and conduct testing activities over Cardano smart contracts. One of its main features is to create fully-fledged transactions from simple declarative skeletons.

Mathieu Montin

6 February 2025

The refactoring of a Haskell codebase

An experience report of a somewhat large refactoring of Liquid Haskell

Facundo Domínguez

21 November 2024

GHC's wasm backend now supports Template Haskell and ghci

A summary of the current support status of Template Haskell and ghci in GHC's wasm backend, explaining how it's implemented and laying out potential future improvements.

Cheng Shao

12 September 2024

Reflecting away from definitions in Liquid Haskell

Internship report: Extensions to the reflection mechanism of Liquid Haskell to handle functions from dependencies.

Jonathan Arnoult

22 August 2024

Programming Languages & Compilers Activity Report - Q2 2024

A summary of the open-source work done by the Programming Languages & Compilers team at Tweag in the second quarter of 2024.

Yann Hamdaoui

15 August 2024

Let there be types: observable type sharing for GHC Core

A tale of optimising GHC by improving sharing in its intermediate representation.

Joseph Fourment

30 May 2024

Liquid Haskell through the compilers

An experience report on plugin upgrades

Facundo Domínguez

7 March 2024

Extending destination-passing style programming to arbitrary data types in Linear Haskell

This blog post presents a safe API for destination-passing style programming using Linear Haskell against arbitrary functional data types.

Thomas Bagrel

18 January 2024

A look under GHC's hood: desugaring linear types

How GHC's design informs linear types

Arnaud Spiwack

12 October 2023

rhine-bayes: a library for online reactive Bayesian inference

Use monad-bayes and rhine in your interactive machine learning application

Manuel Bärenz

20 July 2023

How to Prevent GHC from Inferring Types with Undesirable Constraints

A GHC pattern for improving the user experience of type-level programs

Nicolas Frisby

22 June 2023

Assumptions for Liquid Haskell in the large

A revamp of the mechanism for introducing assumptions

Facundo Domínguez

15 June 2023

Coverage-guided fuzzing of Haskell programs for cheap

A simple trick to fuzz Haskell programs with libFuzzer

haskell
ghc

Cheng Shao

8 June 2023

Announcing halide-haskell - a Haskell interface for the Halide image and array processing language

halide-haskell is a Haskell wrapper for Halide that allows you write and just-in-time compile high-performance array and image processing kernels.

Tom Westerhout, Alex Drake

1 June 2023

Testing Control-Flow Translations in GHC

Translations of control flow can be tested before the rest of the code generator is ready. The tests examine sequences of abstract state transformations and observations.

Norman Ramsey

11 May 2023

A journey through the auditing process of a smart contract

Embark with the High Assurance Software Group for a guided tour through the stages of a smart-contract audit, secret weapon included.

Florent Chevrou

27 April 2023

Type-safe data processing pipelines

Using type-level dependency tags to verify a Haskell pipeline.

Georg Rudoy

13 April 2023

crem: compositional representable executable machines

How to build state machines in a composable way, controlling which transitions can be executed

Marco Perone

23 March 2023

Linear Constraints: the problem with scopes

How linear constraints get rid of scope functions and why it matters.

Arnaud Spiwack

14 February 2023

smtlib-backends: faster SMT-LIB-based Haskell interface to SMT solvers

Announcement of smtlib-backends, a Haskell library providing a generic interface for interacting with SMT solvers using SMT-LIB

Quentin Aristote

31 January 2023

A Semester of HLS: An Internship Report

An experience report on improving HLS during my internship at Tweag.

Berk Özkütük

26 January 2023

Linear Constraints: the problem with O(1) freeze

How a linear constraint arrow relates to freezing arrays in Haskell.

Arnaud Spiwack

12 January 2023

Haskell at Work

Learning and adopting Haskell is not hard with the right resources at hand.

Marco Perone

22 December 2022

Making GHC faster at emitting code

How we gained 2–3% improvements in compile times by making GHC better at printing code.

haskell
ghc

Alexis King

8 December 2022

Creating a Delta Lake in Haskell with Sparkle

A practical introduction to using Sparkle to write Haskell programs which interface with Delta Lake.

Zhihan Zhang

22 November 2022

WebAssembly backend merged into GHC

Announcing the GHC WebAssembly backend – present and future

Cheng Shao

15 November 2022

Staged programming with typeclasses

Introduction to staged programming in Haskell with typeclasses

haskell

Thomas Bagrel

10 November 2022

Reinforcement Learning for Open Games

How to tap into the power of reinforcement learning while specifying and executing open games in Haskell.

Georgios Karachalias, Noon van der Silk

8 November 2022

Functional programming from sets and functions

Understanding the basic ideas of functional programming by writing a program using only sets and functions

haskell

Marco Perone

3 November 2022

Recompilation avoidance in rules_haskell

Bazel avoids superfluous recompilation for free, but we can make it even better.

Guillaume Genestier

27 October 2022

A nub in the haystack

Exploration of a regression in GHC's bytecode generator performance

haskell
ghc

Torsten Schmits

20 October 2022

Converting a polyglot project build to Bazel: part 1

Painlessly switch your Haskell build from Cabal to Bazel

Karol Czułkowski

18 October 2022

Improving the Probabilistic Programming Language monad-bayes

My experience improving monad-bayes, the probabilistic programming language package, as a Tweag fellow.

Reuben Cohn-Gordon

14 October 2022

Testing stateful systems, part two: Linear Temporal Logic

Carl Hammann

28 July 2022

Profiling non-CPU time in Haskell

Limitations of the GHC profiler and announcement of the timestats library

Facundo Domínguez

21 July 2022

A dialogue with Liquid Haskell

New features to understand old verification failures

Facundo Domínguez

23 June 2022

Incremental builds for Haskell with Bazel

Announcing the new haskell_module rule in rules_haskell

Facundo Domínguez

2 June 2022

Smooth, non-invasive Haskell Stack and Nix shell integration

Integrating Haskell Stack and Nix in a smooth yet non-invasive way, with an explanation, example and template.

haskell
nix

Julien Debon

12 May 2022

Comparing strict and lazy

Arnaud takes a step back from the slogans and examines the trade-offs between lazy and strict languages.

Arnaud Spiwack

5 May 2022

Existential optics

A presentation of an alternative encoding for optics such as lenses and prisms using existential types.

Marco Perone

21 April 2022

Announcing WebAuthn

Announcement of a WebAuthn Haskell library, and a description of how the protocol works

haskell

Erin van der Veen and Silvan Mosberger

24 February 2022

Named Routes in Servant

Use records to structure your Servant APIs

haskell

Gaël Deest

17 February 2022

Type-checking plugins, Part III: writing a type-checking plugin

A tutorial on how to write a type-checking plugin for GHC

Sam Derbyshire

10 February 2022

Ormolu: the challenge of formatting operator chains

Why formatting chains of infix operators is hard in Haskell. And how I addressed it for Ormolu.

Thomas Bagrel

26 January 2022

A Case Study on Correctness and Safety Testing of Stateful Systems

How to automatically inject attacks and faults in safety tests using random traces.

Victor Miraldo

19 January 2022

Why Liquid Haskell matters

On the relevance of Liquid Haskell in programming languages

Facundo Domínguez

5 January 2022

Scoped Effect Resources for Polysemy

How to transparently separate resource allocation from business logic for scoped effects in Polysemy

haskell

Torsten Schmits

9 December 2021

Type-checking plugins, Part II: GHC's constraint solver

In part two of this series on type-checking plugins, we will see how GHC's constraint solver works.

Sam Derbyshire

25 November 2021

The Varieties of the Haskelling Experience

A collection of ways various Tweagers develop in Haskell

haskell

Noon van der Silk

4 November 2021

A Haskell memory leak in way too much detail with Cachegrind

Small tutorial on using valgrind to find hot spots in ghc and other Haskell programs

Jeffrey Young

28 October 2021

Hacking on Ormolu: An internship report

An experience report on polishing Ormolu, the Haskell code formatter, during my internship at Tweag.

Alexander Esgen

21 October 2021

Type-checking plugins, Part I: Why write a type-checking plugin?

Why would you want to write a type-checking plugin? Many limitations of the GHC type-checker are exposed here.

Sam Derbyshire

13 October 2021

Denotational Homomorphic Testing

Property test a denotational model of a data structure.

haskell

Divesh Otwani

23 September 2021

Functional data pipelines with funflow2

Introducing a library for writing data pipelines which compose well and fail early

Dorran Howell, Guillaume Desforges, and Vince Reuter

30 August 2021

Daily ICFP: Day 5

Notes from the sixth day of ICFP

icfp
haskell

Noon van der Silk, Arnaud Spiwack, Richard Eisenberg

27 August 2021

Daily ICFP: Day 4

Notes from the fifth day of ICFP

icfp
haskell

Noon van der Silk, Richard Eisenberg

26 August 2021

Daily ICFP: Day 3

Notes from the fourth day of ICFP

icfp
haskell

Noon van der Silk, Arnaud Spiwack, Richard Eisenberg

25 August 2021

Daily ICFP: Day 2

Notes from the third day of ICFP

icfp
haskell

Noon van der Silk, Arnaud Spiwack, Richard Eisenberg

24 August 2021

Daily ICFP: Day 1

Notes from the second day of ICFP

icfp
haskell

Noon van der Silk, Arnaud Spiwack, Richard Eisenberg

23 August 2021

Daily ICFP: Day 0

Notes from the first day of ICFP

icfp
haskell

Noon van der Silk, Richard Eisenberg

28 July 2021

Convert Cabal-based projects to Bazel automatically

Announcing the gazelle_cabal tool for automatic Bazel rules generation for Cabal projects

Facundo Domínguez and Andreas Herrmann

8 July 2021

Exploring linear Traversable using generics

What should the type of linear traverse be exactly?

Sjoerd Visscher

23 June 2021

Deconstructing classes

Deconstructing the various uses of type classes.

haskell

Nicholas Clarke

23 April 2021

Ormolu internship

Tweag is looking for interns who want to contribute to Ormolu.

Mark Karpov

15 April 2021

Arrows, through a different lens

How to use lenses and other optics within an Arrow-based framework.

Juan Raphael Diaz Simões

8 April 2021

Ad-hoc interpreters with capability

Define effect interpreters dynamically using reflection

Gaël Deest, Andreas Herrmann

26 March 2021

Incubating the Haskell Foundation

Incubating the Haskell Foundation during 2020.

haskell

Richard Eisenberg, Tim Sears, and Mathieu Boespflug

25 March 2021

How to build hybrid Haskell and Java programs

Discussion on using Bazel with inline-java

Facundo Domínguez, Andreas Herrmann

10 February 2021

linear-base makes writing Linear Haskell easy and fun

Announcing linear-base, a standard library for linearly typed Haskell programs.

Divesh Otwani, Utku Demir

29 January 2021

Intern opening to improve GHC performance

A call to action to improve GHC's performance via a paid internship

haskell

Richard Eisenberg

7 January 2021

Haskell dark arts, part I: importing hidden values

How to break encapsulation and import a hidden value in Haskell.

haskell

Cheng Shao, Richard Eisenberg

3 December 2020

The Shrinks Applicative

An applicative functor to define shrinkers

haskell

Arnaud Spiwack

25 November 2020

A tale of Template Haskell and cross compilation

Why Template Haskell is hard for cross compilation and how Asterius does it

Cheng Shao, Georgios Karachalias

11 November 2020

Pure destination-passing style in Linear Haskell

Destinations give you control over your memory allocations, and linear types make them pure.

Arnaud Spiwack

9 October 2020

Edge computing with servant on Cloudflare

Cheng Shao

7 October 2020

Making GHCIDE smarter and faster: a fellowship summary

Summary of the Tweag open source fellowship work related to ghcide

Zubin Duggal

30 September 2020

Fully statically linked Haskell binaries with Bazel

Bazel gains support for creating fully statically linked Haskell binaries with rules_haskell and rules_nixpkgs.

Will Jones (Habito) and Andreas Herrmann

13 July 2020

Qualified do: rebind your do-notation the right way

Announcement of the upcoming QualifiedDo language extension.

Matthías Páll Gissurarson (Chalmers), Facundo Domínguez, Arnaud Spiwack

29 June 2020

Splittable pseudo-random number generators in Haskell: random v1.1 and v1.2

How we ensured that the implementation of random v1.2 produces higher quality random numbers than v1.1.

haskell

Leonhard Markert

19 June 2020

Linear types are merged in GHC

Looking back at the journey which brought us there, and forward to what still lies ahead.

Arnaud Spiwack

11 June 2020

Calling to the JVM from Haskell: Some benchmarks

Benchmarks of inline-java and a discussion of its performance trade-offs.

Facundo Domínguez

6 May 2020

A taste of Bazel: build a library, a service and hspec tests

How to build a complete Haskell project with Bazel.

Clément Hurlin

23 April 2020

Deriving Isomorphically

How to derive instances via arbitrary isomorphisms.

haskell

Hans Hoeglund

16 April 2020

The three kinds of Haskell exceptions and how to use them

Imprecise, synchronous, asynchronous exceptions: what do they mean, and what to do with them.

haskell

Arnaud Spiwack

2 April 2020

Eager vs. Lazy Instantiation: Making an Informed Decision

This blog post describes the tradeoffs of the choice between eager and lazy instantiation of type variables in GHC.

Gert-Jan Bottu

12 March 2020

Inferred or Specified Types? Your Choice!

During my internship, I implemented the explicit specificity proposal to make GHC type signatures complete.

Gert-Jan Bottu

5 March 2020

Code is Engineering, Types are Science

Peirce divides reasoning into three complementary processes: deduction, abduction and induction. In this post, I will show how these logical processes relate to software.

haskell

Juan Raphael Diaz Simões

26 February 2020

Probabilistic Programming with monad‑bayes, Part 3: A Bayesian Neural Network

In this blog post series, we're going to lead you through Bayesian modeling in Haskell with the monad-bayes library. In the third part of the series, we setup a simple Bayesian neural network.

Siddharth Bhat, Simeon Carstens, Matthias Meschede

19 February 2020

On linear types and exceptions

A primer on the interaction between linear types and exceptions in Haskell.

Arnaud Spiwack

6 February 2020

Safe memory management in inline-java using linear types

In this post about inline-java I aim to walk you through the upcoming safe interface of the library, which allows detecting memory management mistakes at compile time using linear types.

Facundo Dominguez

30 January 2020

Locating Performance Bottlenecks in Large Haskell codebases

This post describes a profiling technique for Haskell codebases that yields faithful results and is well adapted to large repositories.

Juan Raphael Diaz Simões

16 January 2020

A Tale of Two Functors or: How I learned to Stop Worrying and Love Data and Control

Haskell's Data and Control module hierarchies have always bugged me. Now, I understand that the intuition behind the Data/Control separation is rooted in a deep technical justification.

Arnaud Spiwack

19 December 2019

Haskell art in your browser with Asterius

Asterius compiles Haskell code into WebAssembly code to be executed in a browser or in Node.js. It has reached a new milestone by being able to compile the diagrams library and its dependencies.

Sylvain Henry (IOHK), Cheng Shao

8 November 2019

Probabilistic Programming with monad‑bayes, Part 2: Linear Regression

Here's Part 2 in Tweag's Series about Bayesian modeling in Haskell with the monad-bayes library.

Siddharth Bhat, Matthias Meschede

30 October 2019

Here You See the Small Porcupine Perched in Its Tree, Preparing and Crunching Some Data with Me

We're happy to announce the first release of Porcupine, an open source framework to express portable and customizable data pipelines.

Yves Parès

11 October 2019

Ormolu: Announcing First Release

We're happy to announce the first release of Ormolu, a formatter for Haskell source code.

Mark Karpov, Utku Demir

9 October 2019

Bazel, Cabal, Stack: Why choose when you can have them all?

Bazel gets native support for third-party Haskell libraries and building Cabal packages since the 0.10 release of rules_haskell.

Mathieu Boespflug, Andreas Herrmann

25 September 2019

Bazel's Persistent Worker Mode for GHC: An Industrial Internship

I got the opportunity to work on Bazel's Persistent Worker Mode for GHC during my internship at Tweag. My goal was to improve the mode of communication between Bazel and the Haskell GHC compiler.

Artem Pelenitsyn

20 September 2019

Probabilistic Programming with monad‑bayes, Part 1: First Steps

In this blog post series, we're going to lead you through Bayesian modeling in Haskell with the monad-bayes library. In the first part of the series, we introduce two fundamental concepts of `monad-bayes`: `sampling` and `scoring`.

Siddharth Bhat, Simeon Carstens, Matthias Meschede

12 September 2019

War Stories of Asterius: Numerics & Debugging

I got the opportunity to work on Asterius, a new Haskell to WebAssembly compiler, during my internship at Tweag. My task was to get anything numerics-related stabilized in its compiled code.

Siddharth Bhat

6 September 2019

Why Haskell is important

People keep asking me, “What's the point of Haskell, why do you folks even use it?”. How can you answer this?

haskell

Mark Karpov

27 June 2019

CPP considered harmful

haskell

Mathieu Boespflug

27 May 2019

Ormolu: Format Haskell code like never before

Mark Karpov

9 May 2019

inline-js: seamless JavaScript/Haskell interop

haskell

Cheng Shao

20 March 2019

Capability is about free monads. It's a bird… It's a plane… It's a free monad!

There has been recent online discussions about impredicative encoding (aka final encoding) of free monads. Capabilities-as-type-classes, as embodied by the capability library, are essentially the same thing.

Arnaud Spiwack

13 February 2019