View source for Web/Frameworks/Inactive

These frameworks are suspected to be inactive. If you see that one is not, please move it to the [[Web/Frameworks|Frameworks]] page.
== miku ==

A simple library for fast web prototyping in Haskell, inspired by Ruby's Rack and Sinatra.

{| class="wikitable"
! License
| 	BSD3
|-
! Author
| 	Wang, Jinjing
|-
! Maintainer
| 	Wang, Jinjing <nfjinjing@gmail.com>
|-
! Package & repositories
| [http://hackage.haskell.org/package/miku Hackage] - [http://github.com/nfjinjing/miku Github]
|}

== Lemmachine ==

Lemmachine is a REST'ful web framework that makes it easy to get HTTP right by exposing users to overridable hooks with sane defaults. The main architecture is a copy of Erlang-based Webmachine, which is currently the best documentation reference (for hooks & general design).

Lemmachine stands out from the dynamically typed Webmachine by being written in dependently typed Agda. The goal of the project is to show the advantages gained from compositional testing by taking advantage of proofs being inherently compositional. See proofs for examples of universally quantified proofs (tests over all possible input values) written against the default resource, which does not override any hooks.

[http://github.com/larrytheliquid/Lemmachine#readme More information]

{| class="wikitable"
! Author
| Larry Diehl
|-
! Packages & repositories
| [http://github.com/larrytheliquid/Lemmachine Github]
|}

== Salvia ==

Salvia is a feature rich modular web server and web application framework that can be used to write dynamic websites in Haskell. From the lower level protocol code up to the high level application code, everything is written as a Salvia handler. This approach makes the server extremely extensible. To see a demo of a Salvia website, please see the salvia-demo package.

All the low level protocol code can be found in the salvia-protocol package, which exposes the datatypes, parsers and pretty-printers for the URI, HTTP, Cookie and MIME protocols.

This Salvia package itself can be separated into three different parts: the interface, the handlers and the implementation. The interface module defines a number of type classes that the user can build the web application against. Reading the request object, writing to the response, or gaining direct access to the socket, all of these actions are reflected using one type class aspect in the interface. The handlers are self contained modules that implement a single aspect of the Salvia web server. The handlers expose their interface requirements in their type context. Salvia can have multiple implementations which can be switched by using different instances for the interface type classes. This package has only one implementation, a simple accepting socket loop server. The salvia-extras package has two additional implementations. Keeping a clear distinction between the abstract server aspects and the actual implementation makes it very easy to migrate existing web application to different back-ends.

{| class="wikitable"
! License:
| 	BSD3
|-
! Author:
| 	Sebastiaan Visser
|-
! Maintainer:
| 	sfvisser@cs.uu.nl
|-
! Announcement:
|  http://www.haskell.org/pipermail/haskell-cafe/2010-March/074870.html
|-
! Package & repositories
| [http://hackage.haskell.org/package/salvia Hackage] - [http://github.com/sebastiaanvisser/salvia Git]
|}

== MFlow==

A Haskell application server ++ Web Framework. MFlow is a shorthand for "Message Flow". It is a continuation-based framework without continuations. Instead of other continuation based frameworks like Ocsigen(Ocaml), Coccoon (javascript) or Seaside (Smalltalk), it is based on a backtracking monad that keep the synchornization of the execution state with the user navigation. Since the discontinuation of [http://www.informatik.uni-freiburg.de/~thiemann/WASH/ WASH], MFlow is the only continuation-style framework written in Haskell to date.

Unlike real continuations, the state in MFlow applications is pretty small and serializable, so it is horizontally scalable. The navigation in a MFlow application is safe at compilation time, since even the internal HTML links are checked by the compiler. The code is very short and has little configuration. Routes in MFlow are defined and typechecked in pure haskell code, just like in the case of the menus in a console application. Each page has its own URL so it is RESTful to a certain extent. It is planned to have REST-style URLs in the future (done in the head of the github repo).

It uses standard Haskell web libraries and/or techniques: WAI, Warp, Blaze HTML, HSP. Its core is server and rendering independent. A kind of extended [http://groups.inf.ed.ac.uk/links/formlets/ formlets] are used to create  self contained components, called widgets. They have formatting, Ajax, and server code. They can be composed  to create the user interface.

A MFlow application resembles a console application. This is an example of a complete application with three pages. It ask for two numbers and return the sum. At any time, even if the user press the back button, the state is synchronized with the navigation. 

    module Main where
    import MFlow.Wai.Blaze.Html.All

    main= do
      addMessageFlows  [("sum", transient . runFlow $ sumIt )]
      wait $ run 8081 waiMessageFlow

    sumIt= do
      setHeader $ html . body
      n1 <- ask $   p << "give me the first number" 
                ++> getInt Nothing 
                <** submitButton "send"

      n2 <- ask $   p << "give me the second number" 
                ++> getInt Nothing 
                <** submitButton "send"

      ask $   p << ("the result is " ++ show (n1 + n2)) 
          ++> wlink () << p << "click here"
  


{| class="wikitable"
! License:
|  BSD3
|-
! Author:
|  Alberto Gómez Corona
|-
! Maintainer:
|  Alberto Gómez Corona
|-
! Home page:
|  http://haskell-web.blogspot.com
|-
! Documentation:
|  http://hackage.haskell.org/package/MFlow
 [https://docs.google.com/file/d/0B2-x2MmiuA32b0RndnZTdTVUb0E MFlow paper]
|-
! Package & repositories
| [http://hackage.haskell.org/package/MFlow Hackage] - [https://github.com/agocorona/MFlow Git]
|}

== Wheb ==

Wheb's a WAI framework for building robust, high-concurrency web applications simply and effectively. Its primary goal is to extend the functionality of the base WAI library and to provide an easy entry point into Haskell web servers. The only prerequisite is "Learn you a Haskell" or another introductory Haskell course. It comes with lots of examples on the github page.

* The core datatype will let you build anything from a read-only server to a fully interactive web application with basic Haskell.
* Minimal boilerplate to start your application.
* Session, Auth and Cache interfaces are built in. Just drop in a backend.
* Choice between type-safe web-routes or simpler pattern-based named-routes.
* Easy to use for REST APIs
* WebSockets
* Fully database and template agnostic
* Easy handler debugging.
* Middleware

Wheb makes it easy to write plugins. Plugins can add routes, middleware, settings and even handle resource cleanup on server shutdown. Named routes allow plugins to dynamically generate their routes at runtime based on settings. 

* Sessions
* Auth
* Cache
* [http://hackage.haskell.org/package/wheb-mongo Wheb-Mongo]
* [http://hackage.haskell.org/package/wheb-redis Wheb-Redis]
* [http://hackage.haskell.org/package/wheb-strapped Wheb-Strapped]

{| class="wikitable"
! License:
|  BSD3
|-
! Author:
|  Kyle Hanson
|-
! Maintainer:
|  Kyle Hanson
|-
! Home page:
|  https://github.com/hansonkd/Wheb-Framework
|-
! Documentation:
|  http://hackage.haskell.org/package/Wheb
|}

== WebApi ==

WebApi is a light weight, WAI based library that lets you define your requests and responses for end-points as types by means of a contract. The contract is considered the single source of truth, using which WebApi lets you to 

* Write Web/REST API services
* Generate Haskell client for existing API services
* Generate mock server to mock requests and responses

WebApi makes use of the strong type system of haskell which lets to

* Create a type safe routing system.
* Enable type safe generation of links.
* Specify a contract for the APIs.
* Auto serialization and deserialization of the request and response based on api contract.
* Write handlers which respect the contract.


{| class="wikitable"
! License:
|  BSD3
|-
! Author:
|  ByteAlly Software Pvt Ltd 
|-
! Maintainer:
|  ByteAlly team
|-
! Home page:
|  http://byteally.github.io/webapi/
|-
! Documentation:
|  http://byteally.github.io/webapi/
|-
! Package & repositories
| [https://hackage.haskell.org/package/webapi Hackage] - [https://github.com/byteally/webapi Git]
|}
== Hajax ==

Hajax is a proposal to create a Haskell-based tool to program 'stand-alone' Ajax applications.

'''Wiki page:''' http://www.haskell.org/haskellwiki/Hajax

== Haskell web tool kit ==

Haskell Web Toolkit (further referred to as HsWTK) is a thin layer built on top of DOM interfaces. It provides program interfaces to compose static layout of a web application page, and to hook up visual elements of an application to event handlers and XML HTTP communication means. HsWTK hides the low-level DOM APIs where possible; however their knowledge may be necessary to develop certain types of visual components and event handlers.

'''Wiki page:''' [[Haskell_in_web_browser#Haskell_web_toolkit]]

== HSP ==

Haskell Server Pages (HSP) is an extension of vanilla Haskell, targetted at the task of writing dynamic server-side web pages. Features include:

Embedded XML syntax

A (low-to-mid-level) programming model for writing dynamic web pages

A cgi-handler utility (as a separate package, hsp-cgi)

For details on usage, please see the website, and the author's thesis.

'''License:'''	BSD3

'''Author:'''	Niklas Broberg, Joel Bjornson

'''Maintainer:'''	Niklas Broberg <niklas.broberg@chalmers.se>

'''Home page:''' http://code.google.com/p/hsp/

'''Wiki page:''' [[HSP]]

== HWSProxyGen ==

This website presents a web services proxy generator for the Haskell functional language, implemented in Haskell and C#. The final purpose is to show that Haskell and functional languages in general can be used as a viable way to the implementation of distributed components and applications, interacting with services implemented in different languages and/or platforms.

Homepage: http://www.cin.ufpe.br/~haskell/hwsproxygen/

== hvac == 

The aim of hvac is to provide an environment that makes the creation of lightweight fastcgi-based web applications as simple as possible, with an emphasis on concise, declarative style code, correct concurrent transactional logic, and transparency in adding caching combinators.

'''Announcement:''' http://fmapfixreturn.wordpress.com/2008/03/23/ann-hvac-01b-a-transactional-declarative-framework-for-lightweight-web-applications/

'''Documentation:''' http://community.haskell.org/~sclv/hvac/html_docs/hvac/

'''Home page:''' http://community.haskell.org/~sclv/hvac/

== WASH ==

An extended version of Simon Marlow's webserver (hws) that runs WASH modules as servlets. WASH modules are compiled transparently and dynamically loaded into the running server. Each servlet runs in one of three modes: LogOnly (using a log to reconstruct the current state like WASH's CGI implementation), StateIDOnly (running a thread for each session and continuing in the same thread with each form submission), LogAndState (use a thread for efficiency and keep the log for robustness).

'''Author:''' Simon Marlow

'''Home page:''' http://www.informatik.uni-freiburg.de/~thiemann/WASH/#wsp

== Web functions ==

From the site: "WebFunctions is a domain specific embedded language for web authoring, implemented in Haskell. The functionality of the WebFunctions framework was inspired by Apple's WebObjects. We claim it is easier to use since the Haskell type checker makes a lot of extra checks, that are absent from the Apple framework. Unfortunately we do not yet have all the nice tooling and special editors, but we are working on this."

'''Author:''' Robert Van Herk

'''Home page:''' http://www.cs.uu.nl/wiki/WebFunctions/WebHome


== Turbinado ==

Turbinado is a Rails-ish MVC web framework for Haskell. Turbinado gives you all of the benefits of coding in Haskell and adds:
http://www.cin.ufpe.br/~haskell/hwsproxygen/
* A fast HTTP server with static- and dynamic-content serving capabilities;
* Views built using HTML, HAML or Haskell templating syntax;
* Automagic recompilation of Controllers, Layouts and Views;
* A database ORM to make database interaction (especially with PostgreSQL) joyful;
* A rich set of tags to make designing pages simpler;.

{| class="wikitable"
! Author:
|  Alson Kemp
|-
! Package & repositories:
| [http://github.com/alsonkemp/turbinado Github]
|}

== Bird ==
A Loli (Haskell) / Sinatra (Ruby) inspired web framework

'''Home page:''' https://github.com/moonmaster9000/bird