Error formatting macro: pagetree: java.lang.NullPointerException
Skip to end of metadata
Go to start of metadata
You are viewing an old version of this page. View the current version. Compare with Current  |   View Page History


Information for Students

These ideas were contributed by our developers and users. They are sometimes vague or incomplete. If you wish to submit a proposal based on these ideas, you may wish to contact the developers and find out more about the particular suggestion you're looking at.

Being accepted as a Google Summer of Code student is quite competitive. Accepted students typically have thoroughly researched the technologies of their proposed project and have been in frequent contact with potential mentors. Simply copying and pasting an idea here will not work. On the other hand, creating a completely new idea without first consulting potential mentors is unlikely to work out.

If there is no specific contact given you can ask questions on the general Clojure Google Group -

Adding a Proposal

Please follow this template. If you don't have Confluence access please submit your idea following this template to this thread -

Brief explanation:

Expected results:

Knowledge Prerequisite:


When adding an idea to this section, please try to include the following data:

If you are not a developer but have a good idea for a proposal, get in contact with relevant developers first.

Project Ideas


Predicate Dispatch

Brief Explanation: A considerable amount of work has been done towards a viable predicate dispatch implementation for Clojure. However quite a few more enhancements to core.match are required before it can be used for this purpose. The work should account for other Clojure dialects ClojureCLR / ClojureScript.

Expected Results: A usable implementation of predicate dispatch.

Knowledge Prerequisite: Familiarity with Clojure. Familiarity with Chambers / Chen efficient predicate dispatch paper and Luc Maranget's paper on compiling pattern match expressions into good decisions trees.

Skill Level: Medium

Mentor: David Nolen

cKanren extensions to core.logic

Brief Explanation: Adding constraint logic programming facilities to core.logic would widen the scope of problems that core.logic can be applied to - including predicate dispatch. We would like to adapt the cKanren extensions to core.logic with an eye for obvious improvements to the their design in terms of generality as well as performance.

Expected Results: core.logic with cKanren extensions.

Knowledge Prerequisite: Familiarity with Clojure. Familiarity with Chapter 3 of William Byrd's dissertation and the recent cKanren paper.

Skill Level: Medium to High

Mentor: David Nolen

Linter based on Ambrose's analyzer work

Leaner Clojure runtime

Brief Explanation: Currently, Clojure has a relatively heavyweight bootstrap process that is troublesome for embedded and hosted environments with limited computing power and for scripting where the JVM/Clojure bootstrap undesirably dominate execution time.  There are a number of ideas on how to accomplish this, including removing metadata and the compiler from non-development builds and changing the compiler to generate static method calls instead of invoking functions on function objects.  The goal for this project would be to implement and refine one or more of these or similar ideas to help Clojure perform better in lightweight applications and limited environments.

Expected Results: A lightweight build of Clojure that bootstraps more quickly and uses less memory.

Knowledge Prerequisite: Familiarity with Clojure, especially with the Clojure compiler.

Skill Level: Medium to High

Mentor: Daniel Solano Gómez



Lightweight Clojure editor, repl, and documentation browser ala

Brief explanation: Currently everyone using Overtone must setup a clojure environment and editor, but it would be great if people who are unfamiliar with software development and/or clojure (e.g. musicians, artists, etc...) could download a single application to easily experiment with pre-existing instruments, sequencers, samplers, fx-racks made for guitars or other external instruments, etc.  The app would let someone browse a built-in library of examples, evaluate code, experiment in a repl, open and save text files.  The or SuperCollider applications are examples of this kind of system.

This kind of app would probably be useful for other Clojure projects too, so as part of it there would probably be a number of general purpose elements that could be made available as standalone libraries.

Expected results: An app implemented with the seesaw gui library (and maybe upshot for the JavaFX webkit widget for documentation) with a simplistic text editor that syntax highlights clojure, allows for selecting and evaluating chunks of code, and a repl panel.

Knowledge Prerequisite: Familiarity with Clojure and a bit of swing or other GUI experience.

Mentor: Jeff Rose

Skill Level: Beginner / Intermediate


Node based GUI editor for synthesis and bus routing

Brief explanation: While programming synthesizers and setting up a mixing board system are great in Clojure, visual representations can be great for teaching, learning, and performance, because they represent the flow of audio and control data in a direct way that can be easier to follow than tracing a series of nested function calls.  It would be great if Overtone had a graphical editor similar to Max/MSP, which allowed someone to choose from a library of unit-generators (DSP functions) and then wire them up together.  The ugens in Overtone have extensive meta-data about their types, rates, functionality, and arguments, so this would primarily be a GUI programming and graphic design project.

This widget could also be useful for other projects that want to display or manipulate graph or tree structured data, so some of the underlying functionality could be made available as a separate library.

Expected results: A node editor widget implemented using a 2d scenegraph using Dave Ray's upshot library ( on top of JavaFX 2.  Synth designs could be loaded or saved by the widget.

Knowledge Prerequisite: Programming with Clojure, and ideally some experience using a node based editor (a couple evenings doing Max/MSP or PD tutorials would be sufficient).

Mentor: Jeff Rose

Skill Level: Beginner / Intermediate


Multi effects processor application for guitar, vocals, or any input instrument 

Brief explanation: Create a standalone application that any musician could download and use as a pure software effects processor on their computer.  The idea is to create a simple to use, open-source platform that lets people easily experiment with and contribute new FX to the application by writing effects synthesizers in Overtone.

Expected results: Implement a library of nice sounding audio effects using Overtone, and then package them up in a simple Swing application using seesaw so non-programmers could plug an instrument into their sound-card and easily apply a chain of effects to the audio.

Knowledge Prerequisite: Programming with Clojure, sufficient knowledge of audio DSP to research and implement a collection of audio effects.

Mentor: Jeff Rose

Skill Level: Intermediate / Advanced


Performance enhancements

Brief Explanation: ClojureScript has numerous areas where the performance can be dramatically improved. These include but are not limited to removing use of arguments in multiple arity function dispatch, adding persistent data structures, and using type inference. A benchmark suite similar to test.benchmark for tracking improvements and regressions would be desired, the benchmark suite should provide idiomatic JavaScript as the baseline.

Expected Results: Improved overall performance verified by a benchmark suite.

Knowledge Prerequisite: Familiarity with Clojure.

Skill Level: Medium

Mentor: David Nolen

Introspection support

Brief Explanation: ClojureScript currently has very limited introspection support. Currently it's impossible to view macroexpansion, to examine docstrings, examine vars or namespaces, etc.

Expected Results: Improved introspection facilities more in the line with those provided by Clojure.

Knowledge Prerequisite: Familiarity with Clojure.

Skill Level: Medium

Mentor: David Nolen

Debugger support

Brief Explanation: ClojureScript currently provides very little support for precise debugging. Source mapping would be an initial step. All the mature JavaScript runtimes provide APIs for stepping through JavaScript. A robust interface for integrating with these different APIs is desirable. A concrete implementation for Chromium or Node.js would be extremely useful to ClojureScript developers. An ambitious take on this project would be s-expr level stepping of ClojureScript code.

Expected Results: A clean interface for integrating with existing JavaScript debugging APIs. A concrete implementation for a popular JavaScript platform - Chromium, Node.js.

Knowledge Prerequisite: Familiarity with Clojure.

Skill Level: High

Mentor: David Nolen

Pluggable backend

Brief Explanation: The ClojureScript compiler is currently very JavaScript-centric. It would be beneficial to make the compiler pluggable. This would allow ClojureScript developers to easily target other platforms - Lua, Python, Java, etc.

Expected Results: A compiler that can easily be extended to generate source / bytecode for other languages.

Knowledge Prerequisite: Familiarity with Clojure.

Skill Level: Medium

Mentor: David Nolen



Add Android support to Clojure

Brief explanation: There is currently a fork of Clojure designed to support Android.  This fork is designed to support dynamic compilation on the Dalvik virtual machine.  It also contains some workarounds to ensure that Clojure will work (even without dynamic compilation) on older versions of Android.  It would be great to have some of these changes integrated into the main Clojure repository.  Also, Clojure 1.3 and newer do not work with versions of Android older than Gingerbread.

Expected results: Integrating Android-friendly features into Clojure and ensuring newer versions of Clojure work with Android platforms Eclair and newer.

Knowledge prerequisite: Clojure, Dalvik VM.

Skill level: Medium to hard.

Mentor: Daniel Solano Gómez

Clojure/Android Toolkit

Brief explanation:  There is the start of a library for Android development using Clojure.  It is quite incomplete and needs significant enhancements, for example adding macros such as defactivity to help ease the boilerplate for generating new Android component subclasses, creating utilities to help manage coordination between the UI and background tasks in a Clojure-friendly way, or even creating a Leiningen plug-in to help developers get started. 

Expected results: The developer will need to propose a series of enhancements to the toolkit, implement them, and provide documentation on how to use them.

Skill level: Easy to medium

Mentor: Daniel Solano Gómez