Created and curated by Pete Hodgson .

The Todo-Backend project defines a simple web API spec - for managing a todo list. Contributors implement that spec using various tech stacks. Those implementations are cataloged below. A spec runner verifies that each contribution implements the exact same API, by running an automated test suite which defines the API. The Todo-Backend project was inspired by the TodoMVC project , and some code (specifically the todo client app) was borrowed directly from TodoMVC.

Perl / Catalyst todo backend implemented with perl and Catalyst. Backed with a plain file on disk.

Perl / Mojolicious todo backend implemented with perl and mojolicious. Backed with a plain file on disk.

Perl / PEF::Front todo backend implemented with perl and PEF::Front. web framework, saving todos to a Postgres DB.

Ruby / Sinatra A simple ruby implementation using the lightweight Sinatra web framework, saving todos to a Postgres DB.

Ruby / Grape A Ruby implementation using Grape.

Rust / Iron A Rust implementation using Iron with a thread-safe in-memory repository

Rust / Rocket A Rust implementation using Rocket.

Node.js / Express Node.js + Express, saving to Postgres. Courtesy of Daniel Tao.

Node.js / Express / JS-CSP Node.js + Express + JS-CSP (an alternative to Promises and callbacks), saving to Postgres. Courtesy of Andrew Kiellor.

Node.js / Express / Knex.js Node.js + Express + Knex (query builder configured to save to Postgres). Implementation uses async/await. Courtesty of Tony Cheang.

Node.js / Hapi.js Hapi.js saving to a MongoDB collection via MongooseJS by Pamela Ocampo.

Node.js / Hapi.js / Postgres Node.js example using the Hapi framework and a Bookshelf ORM connected to a Postgres database.

TypeScript / Node.js / Hapi.js Node.js example using the Hapi framework and saving to memory.

Node.js / Micro / Postgres Node.js example using the Micro framework.

Node.js / SailsJS Node.js implementation in SailsJS by Kix Panganiban.

Python / web.py A simple Python implementation using web.py. This implementation "cheats" by just storing todos in memory in a Dictionary globalton.

Clojure / Compojure A simple Compojure implementation storing to Postgres via clojure.java.jdbc courtesy of Andrew Kiellor.

Clojure / Compojure / H2 Database A simple Compojure implementation storing to H2 File DB via clojure.java.jdbc courtesy of Darren Haken.

Python / Django A database-backed Django implementation courtesy of Mihir Khatwani.

Vanilla Rails A simple Rails implementation courtesy of Derek Hammer.

Java with ActFramework and MongoDB A version using ActFramework by Gelin Luo.

Java 8 with Spring 4 Boot A version using Spring 4 Boot + Java 8 from Jefferson Santos.

Java 7 and Spring MVC Java 7 and Spring MVC implementation using the Java 1.7 and Spring MVC. Deployed to Heroku using a Tomcat runner.

Vert.x and PostgreSQL Backend, based on Vert.x 3 and PostgreSQL.

Java 8 and Vert.x An implementation using Java 8 and Vert.x from Alex Somai.

Vert.x with JDBC An implementation using Vert.x with JDBC from Dong-hee Na.

Vert.x with ORM An implementation using Vert.x with ORM(ormlite) from Dong-hee Na.

Jersey2 with RDF for data storage A version using Jersey2 with Sesame RDF for data storage from Michael Leuthold.

Golang / Gin A Golang implementation using the Gin web framework, courtesy of Matt Ho.

Golang / GOA A Golang implementation using the GOA web framework, courtesy of Christoph Meier.

Golang / Echo A Golang implementation using the Echo web framework, courtesy of Simar Kalra.

Scala / Lift A Scala implementation using the Lift framework. This implementation uses a thread-safe in-memory store. Courtesy of Riccardo Sirigu.

Scala / Finatra A Scala implementation using Twitter's Finatra web framework. Courtesy of the prolific Matt Ho.

Scala / Akka A Scala implementation using akka-http. Courtesy of Arnout Engelen

Scala / Akka / Swagger The akka-http framework. The Scala language. Swagger to specify the API and Twilio Guardrails to generate the code.

Kotlin / Http4k Kotlin + http4k with typesafe lenses, saving in-memory.

Kotlin / Rapidoid Kotlin + Rapidoid, saving im-memory.

Kotlin / Ktor / Koin Implementation using Kotlin, Ktor and Koin, saving in-memory.

Node.js / Koa Node.js + Koa, saving to redis.

SWI-Prolog SWI-Prolog 7 implementation using the Prolog database with persistency. Extensively documented.

C# - Nancy (ASP.NET) C# with NancyFx implementation using the Nancy Framework and NDatabase, an inmemory object database.

F# - Freya (OWIN) F# with Freya implementation using the Freya F# OWIN wrapper and an in-memory store built with an F# `MailboxProcessor`.

Java Spring 4.0 and MongoLab DbaaS Java Spring MongoLab DbaaS implementation using the Java 1.7, Spring 4.0 and MongoDB using MongoLab's database as a service.

Vert.x 3 and Redis backend A Java implementation using Vert.x with Redis backend. Deployed on OpenShift. By Eric Zhao

F# - Frank F# with Frank implementation using Frank, a minimal combinator library built on top of System.Net.Http types in F#, hosted via OWIN, and using an in-memory store built with an F# `MailboxProcessor`.

Java with Dropwizard Simple implementation with Java + Dropwizard from Dan Siwiec.

C# with ServiceStack An implementation using the ServiceStack framework, ormlite, sqlite, NUnit by Kyle Hodgson.

Golang / stdlib A Golang implementation using only the standard libraries

Golang / stdlib / Makefile A Golang implementation using only the standard libraries

Vert.x / Mongo / Java8 Implemented using Vert.x + MongoDB, written in Java8 from Vithulan

Node.js / Express / CoffeeScript / Mongo Node.js + Express, written in CoffeeScript from Dan Siwiec. Data is persisted to MongoDB using Mongoose

F# - Suave A simple implementation using Suave

Scala - Play! Scala implementation on the Play framework backed by Postgres

OCaml OCaml implementation. Courtesy of Arnout Engelen

Elixir - Phoenix / Postgres Elixir implementation using the Phoenix Framework backed by Postgres. Deployed to Heroku using the Elixir buildpack. Courtesy of Jeff Weiss

Elixir - Maru / Postgres Elixir implementation using the Maru Framework and Ecto ORM backed by Postgres. Deployed to Heroku using the Elixir buildpack. By Charles Whitfield

Elixir - Plug / Postgres Elixir implementation using the Elixir Plug and Ecto ORM backed by Postgres. Deployed to Heroku using the Elixir buildpack. By Rajesh Sharma

Java - Axon + Spring Boot Implementation using Axon, a Java CQRS framework, + Spring Boot. This version "cheats" by storing todos in an in-memory repository. By Ryan Oglesby

Python / Flask Implementation written in Python with Flask.

Python / Circuits Implementation written in Python with Circuits Framework.

Python / aiohttp Implementation written in Python 3.5 with aiohttp by Justus Perlwitz.

Python / Falcon Implementation written in Python 2.7 with Falcon by Kix Panganiban.

Python / Sanic Implementation written in Sanic by Kix Panganiban.

Python / Molten Implementation written in Molten by Kix Panganiban.

Haskell - Scotty / Persistent Haskell implementation using Scotty.

Haskell - Servant / Persistent Haskell implementation using Servant.

Haskell - Snap / Persistent Haskell implementation using Snap.

Haskell - Spock / Persistent Haskell implementation using Spock.

Haskell - Yesod / Persistent Haskell implementation using Yesod.

Rust / Rustful Rust implementation using Rustful.

PHP / Symfony2 PHP implementation with Symfony2.

Modern Node.js / MongoDB Node.js implementation using ES6/7 features, built with libraries from Matt Insler. Features use of app-context.

Node.js / Restify / Redux Node.js + Restify, written with pure ES6 from Dan Siwiec. State is maintained with Redux

TypeScript / Node.js / Express TypeScript + Node.js + Express, saving to Postgres.

Slim 3 / Spot PHP implementation with Slim 3 and Spot.

Scala / Finch A Scala implementation using Finch for web and Circe for JSON.

Scala / Fintrospect A Scala implementation using Fintrospect for web and Json4s for JSON.

Swift / Kitura / CouchDB A Swift implementation using Kitura for web.

Swift / Vapor A Swift implementation using Vapor for web.

Scala - Play 2.5 / Postgres A Scala implementation using Play 2.5 with persistance in Postgres using Anorm. By Jorge Lee.

Spincast Framework ~ In memory In memory implementation using Spincast.

Scala - Spring Boot A Scala implementation using Spring Boot By Steven Job.

Nim / Jester Nim + Jester using in-memory data store. By Cody Ebberson.

Crystal / Kemal ~ In memory A Crystal implementation using Kemal.

Scala / http4s (in-memory) A Scala and http4s implementation with an in-memory store

Rails 5 API-only A Rails 5 API-only implementation with MongoDB Backend.

Java 8 / Ratpack A Java 8 implementation using the Ratpack framework, using H2 for persistance

Jooby / In memory Jooby implementation using with an in-memory store

Java 8 / Spark / JDBI A Java 8 implementation using the Spark framework. Persistance to Postgres using JDBI.

C# - ASP.NET Core A C# implementation using ASP.NET Core with Docker support and in-memory or SqlServer persistence. Implements CQS using the Brighter and Darker frameworks.

PHP / Lagan PHP implementation with Lagan.

Azure Functions - C#, F# and JavaScript Azure Functions implementation with functions written in C#, F# and JavaScript. Uses Azure Table Storage for persistence.

Java / VRaptor 4 / JPA / H2 Database A Java implementation using VRaptor 4 framework.

Vanilla Ceylon Plain Ceylon implementation by Andreas Schilling.

Ruby / LittleBoxes A Ruby implementation using LittleBoxes.

mangoo I/O / jOOQ / H2 A Java 8 implementation using the Mangoo I/O framework, jOOQ for database access and H2 in-memory database.

Ceylon / gyokuro A Ceylon implementation using the gyokuro framework.

Kotlin / Spring Boot 2 reactive with annotation Simple implementation using Spring Boot 2 (reactive web) and with Kotlin, saving todos in-memory.

Kotlin / Spring Boot 2 reactive with router Simple implementation using Spring Boot 2 (reactive web) and with Kotlin, saving todos in-memory. Setup is done via the router API

Kotlin / Spring Boot 2 reactive with mongodb Implementation using Spring Boot 2 (reactive web) and Kotlin. Data source is mongo

Kotlin / Spring Boot Implementation using Kotlin and Spring Boot. Items are stored in memory.

Kotlin / Javalin Implementation using Kotlin and Javalin. Items are stored in memory.

Kotlin / Ktor Implementation using Kotlin and Ktor. Items are stored in memory.

Kotlin / Hexagon Kotlin + Hexagon, saving in-memory.

C# - ASP.NET Core 2.0 A simple C# implementation using ASP.NET Core 2.0 with a Docker image and in-memory persistence. Only depends on the standard Microsoft.AspNetCore.All package.

PHP / Laravel PHP implementation using Laravel and a MySQL database

Java / Jodd Java 8 implementation using Jodd 4.

XCST - ASP.NET An XCST implementation for ASP.NET. Items are stored in memory.

Java with NutzBoot Implementation using Nutz Boot by wendal. Items are stored in memory.

F# - Giraffe Implementation using Giraffe in F# by mabe. Items are stored in memory.

Clojure with Luminus and Immutant Implemented in Clojure using Luminus and Immutant.

Java 8 with Java EE 8 Java 8 implementation running on the Java EE 8 compatible Payara Micro as a microservice. ToDos are in-memory.

Ruby / Hanami A Ruby implementation using Hanami.

Ktor / Kotlin Implementation using Ktor by Gopinath Langote. Items are stored in memory.

Python / Masonite Implementation using Masonite by Kentaro Matsuzaki.

Java 11 / Spark / JDBI / no annotations A Java 11 implementation using the Spark framework. Persistence to Postgres using JDBI. No Java annotations.

Scala / ZIO, http4s Todo-Backend (https://www.todobackend.com/) implementation using ZIO, http4s and circe

Pharo / Seaside Implementation for the todo backend using Pharo and Seaside.

Java / Micronaut Implementation using Micronaut. Items are stored in memory H2.

PHP / CakePHP 4 PHP implementation with CakePHP 4.

Java - Spring Boot 2 Implementation using Spring Boot, Gradle as the build tool, and a Postgres database with migrations managed by Flyway. By Brian Sayler.

Kotlin / Hexagon, MongoDb Implementation using Kotlin and Hexagon saving items to a mongoDb database

PHP / Symfony4 with api-platform PHP implementation with Symfony 4, using API Platform.

R / Plumber A todo backend written in R with Plumber.

Javalin / Java 11 A Java 11 implementation using the lightweight and fast Javalin framework.

Quarkus A Quarkus implementation using the Quarkus framework. RESTEasy/JAX-RS and JSON-B extensions and Persistence to Postgres using Hibernate ORM with Panache extension PANACHE.

Node.js / NeDB / Express Nodejs using embbeded database NeDB. Feel free to follow Mauricio Lobo.