Intro Projects

Eric Clack edited this page Apr 4, 2016 · 82 revisions

This page lists Racket projects which are feasible for people who don't have a lot of experience with the Racket code base. They're mostly small, self contained, and would be extremely useful. Some involve writing a new library that would be useful to lots of other people, and some help fix or clean up some aspect of the existing Racket code base.

The best place to ask for help with any of these is on the users mailing list.

Recreational Programming

These are intended to be a collection of fun topics to explore, intended as exercises or mini-projects, but also interesting in their own right. If you implement one, then leave a link: different solutions can lead to comparisons of style and constructive suggestions. Finally, add more ideas ...

  • Graphics
    • Draw some fractals: Mandelbrot set; Julia set; L-systems; Sierpinski gasket; Koch snowflake; space-filling curves
    • Make a random maze; animate the drawing
    • Tile a plane: rectangles - grid or herringbone; triangles; hexagons; Penrose tilings; quilt designs
    • Animate a classic looking clock
    • Animate a word clock
  • Wordplay
    • Find anagrams (example)
    • Find palindromes (example)
    • Make a scrabble or crossword helper
    • Scan a text for haikus
  • Puzzles
  • Calendars
    • Day of the week of any given date
    • When is Easter (and other holidays) in a given year?
  • Cryptography
    • Encrypt / decrypt simple ciphers and codes
    • rot13
    • Crack simple ciphers
  • Programming tools
    • Reimplement some standard library operations
    • Reimplement some of the standard Unix tools
  • Classical mechanics
    • Animate a bouncing ball, then balls
    • Simulate planets in orbit
    • Pendulum
    • Newton's cradle
  • Math
  • Games

Small Projects

These are self-contained projects. Just create a new github repository, and start hacking. When you have something that works, release it on the package catalog. To get started with packages, take a look at its documentation.

  • Implement a Rosetta code task:
    • You could also re-implement or improve an existing Racket solution
  • Implement mini versions of classical programs (can be used as extended examples on the web site):
    • Notepad using racket/gui
    • Paint
    • Calculator
  • Data structures: hash array mapped trie, 2-3 finger trees, other purely functional data structures (some already implemented here).
  • Code for doing OAuth
    • Now available here
    • Also available as part of ryanc's webapi PLaneT package.
  • Write bindings for libgit
  • Write bindings to Authorize.Net
  • Write libraries to interact with Wii Remotes
  • Write libraries to interact with game controllers
    • This exists on for Mac OS X, but an interface should be normalized and available across platforms.
    • maybe use libsdl?
  • Write bindings to various Google APIs
    • Authentication would be useful
    • Other interesting things: docs (esp. around spreadsheets), maps
  • Write bindings to the Github API
    • Basic binding available here
  • Write bindings to the Twitter APIs
  • Write bindings to the Facebook APIs
  • Write bindings to Amazon AWS.
    • Eric Hanchrow has some first steps which might be inspirational.
    • a typed/racket effort by Ray Racine which is actively being developed.
    • Greg Hendershott has untyped Racket code for the S3, SDB, SES, SNS, SQS, CloudWatch, and other services Github.
  • Write XMPP bindings
    • A starting point can be found here
  • Bindings for a text to speech engine
  • IRC log highlighter. Starting points :
  • IRC client library (can be based on the gabot code (contact Eli), which is better for a library than rudybot). Jonathan Schuster has done racket-irc.
  • Bindings for Apple's Core-* Libraries
  • Write a better s-exp diff tool
  • Write bindings to gobject introspection
  • Use the Racket examples on Rosetta Code and the snippets on the home page to make that show cases programs and snippets written in Racket. There's a start of explanations of the home page snippets here:

Code Improvements

These are improvements to the Racket source. Fork the GitHub repository and then submit a pull request.

  • Port code that uses class100 to the current class system (Completed by Asumu)
  • Get rid of units in the net collect (Done by Jon Zeppieri)
  • Fix warnings in C code (Forked to pmatos/racket to sort this one out. Will issue pull request when completed.)
    • Refer to the nightly build logs for our distributed platforms
  • Find uses of alists and replace them with hash tables where appropriate (note that short alists, below ~40 items, can be faster than hashes)
    • Search for uses of assq and friends to find
  • Find things that use lists for sets, replace them with racket/set
    • Search for uses of member and friends to find
  • Find uses of srfi/1, replace them with racket/list stuff
  • Add support for macro-debugger/analysis/check-requires to xrepl (Completed by Eli)
  • Fix Swindle to have call-next-method available without #lang swindle
  • Find uses of log-xxx (using the global logger), and use 5.3.2's new define-logger form to change them to use their own logger. That way, users can filter the log messages. Examples might include "optimizer" and "file dependency" categories of messages.

Documentation Improvements

Similar to code improvements (docs are code).

  • Revise the FFI docs: better docs, lots of examples, guide-like text
  • Add a detailed example to the profiler manual.
  • Documentation clarifications and/or small examples
  • Write tutorials for building small applications and using major features, e.g., the class system or macros.
  • Convert Eli's Swindle documentation to Scribble.


These are improvements to other systems to better support Racket.

  • Racket support for github code highlighting
  • Racket support for github code editing
  • Etags support for Racket features
  • Improve Racket support in Ohloh's line counter
  • Racket support in MediaWiki's GeSHi highligher
    • Awaiting Integration into GeSHi source: Tim Brown has written racket.php, it is scheduled for the next iteration of GeSHi, but the next iteration of GeSHi might be a little while.
  • Extend the gabot IRC bot to deliver messages to offline people (contact Eli for more info)
    • Optionally, extend it to do more cool stuffs
    • rudybot is another possible starting point
  • LightTable plugin for Racket. See the plugin for Haskell for an example.
  • Racket support for (see

Larger Projects

For the more ambitious Racketeer ...

  • Make a web page (demo.racket-lang ?) that contains Racket snippets. Use the programs from to get started.
  • Write a parser for ispell dictionaries. Make DrRacket use it.
  • Write a markdown parser (important: lots of tests; support at least popular variants that are used by stackoverflow and github)
  • Write a YAML parser
  • Write a gitolite replacement in Racket (contact Eli)
  • #lang scsh -- or better: write just a library for similar bindings (macros & functions), and make it into a language that has shell-like syntax
  • Write a blogging framework
    • There's one, named frog.
  • Write a Common Lisp compatibility layer (same functionality, but not all the core language features that would make this extremely difficult; for example: keep immutable pairs)
  • Write a Clojure compatibility layer
    • Started on one here but it needs a lot more work.
  • Write bindings to SDL (note that there are Allegro bindings on planet).
  • Integrate the existing parser-tools SRE with Racket regexps.
  • Write some code metrics tools (number of functions, number of lines, etc) and integrate them with DrRacket's module browser.
  • Write image filters example