Home News Features Screenshots Community Install


2011-04-12 - JazzScheme 2.4, 2.5 and 2.6 released

JazzScheme 2.4, 2.5 and 2.6 are now available. See Install for details on installing Jazz and Jedi.

NEW IN 2.5 and 2.6


  • Now using Git submodules to manage the dependencies between Jedi, Jazz and Gambit
  • Created a fully bootstrappable Gambit repository now included as a submodule of Jazz
  • Added a jam script to manage everything build and repository related


  • Use TCP ports for robust subprocess parallel build
  • Added a -dry kernel build option
  • Added .jamini to customize configure options


  • Removed the hardcoded HOME/jazz_user repository
  • Now generating a clean kernel-interpret script instead of the old .gambcini hack
  • Added a kernel -nosource option to simulate the deployment environment
  • Added support for specifying chained binary repositories
  • Added a -l (local) option to jam to not update the submodules


  • Added reference reification
  • Added assertions to special forms and related validation suite test cases
  • Exemplars are now full-fledged class-based prototypes
  • Colors and fonts and all user configuration classes are now exemplars
  • Module reference syntax is now a.b.c:x
  • Changed core syntax from jazz. to jazz:
  • Added scripting support through a script special-form and a load-script function


  • Added Windows support for OpenGL GLUT
  • Use the new continuation-checkpoint for C frames protection
  • Implemented a cross-platform color chooser with user-customisable live feedback
  • New hierarchical aliases
  • Added push/pop-focus to implement keyboard-navigable menus
  • Added location info to crash snapshots
  • New grid infrastructure
  • Added support for Gambit readtables
  • Added basic JSON support
  • Refactored the text to a model / view architecture


  • Added a new workspace for formatted editing
  • In the login dialog holding the shift key after login will skip the 'Always use this profile' setting
  • Generalized versioned-directory
  • Moved profiles to versioned .jedi dir
  • Dynamic evaluation now collects export / import initial forms


  • Major rework of everything project related
  • Projects are now pure data so that Jedi does not need access to the project modules anymore
  • Pathnames imported in a project will be relative to the project when possible
  • Can now create or install a project at any level in the workbench
  • Added a projects manager window to activate / deactivate projects
  • Added Synchronize Content to workbench directory menu
  • Added searching project files
  • Not finding the active-project doesn't stop Jedi from launching anymore


  • Major recoding of everything search related
  • Now cataloging a.b.X and a:b:c references
  • Who-calls now automatically selects the first occurence
  • Added declaration and selection searching
  • Incremental search replace-all with replace highlighting
  • Added n of m feedback to incremental search
  • Added splitting support similar to emacs c-x c-1,2,3,0 using the new model / view text
  • Integrated the highlighting framework to the incremental search


  • Major work on the UI designer


  • Work on making every part of the UI skinnable
  • Made the following UI elements user customisable :
    • Bindings
    • Colors
    • Fonts
    • Skins
    • Text formats and styles
    • Workspaces


  • Support for multiple backends
  • Experimental JavaScript backend
  • Experimental Objective-C backend

NEW IN 2.4


  • Added support for .jazz settings automatic versioning
  • Added a script to walk all units that can be invoked with -run walk
  • Added -emit to the kernel to save emitted scheme code
  • Added a -build option to the kernel to build a product without its dependencies
  • Now loading .buildini before setting up repositories
  • Added (jazz.warn-interpreted? 'stack) to display load-stack
  • .jazzini and .buildini are now also searched in the current directory
  • Added -keep-c and -expansion options to -compile
  • Improved error reporting for circular unit dependencies

Build System

  • Added a new mutable-bindings? build flag
  • Obliterate timestamps in libraries, executables and .o1 to support stable builds
  • Added make cleanlibrary and make cleanobject to the build system
  • Added a new 'all' build system target to build jedi and all the samples
  • Added support for multiple binary repositories
  • Added a kernel option to specify the build repository: -build-repository
  • Added kernel options for specifying repositories: -jazz-repository -user-repository -repositories


  • Added types for DSSSL special markers (#!optional, #!key and #!rest)
  • Added base64 module (from Gambit's examples)
  • Now supporting slots in meta classes


  • Separated branches into traits and branches
  • Unified view properties: action and action-handler
  • Optimized merge-cell drawing
  • Lexicon cleanup for outlines: site: row column, cell: line col
  • Added a glyph index cache (major speed up)
  • Added a cache for opaque images (major speed up)
  • Now calling cairo_win32_surface_create_with_ddb to create the offscreen on Windows (5x speed up in the blit)
  • Made memory surfaces use CAIRO_FORMAT_RGB24 (with 4x speed gain)
  • Major optimization of the paint algorithm
  • Added various flags to make component destruction a lot more robust
  • Cleanup of the argument/setting concept that is now called parameter
  • Work on external frames
  • Major work in the focus activation code
  • Removed flicker by adding a new user-feedback function to use when immediate update is needed
  • Snapshots now save object content recursively controlled by max-depth: default 1
  • Added basic support for fontconfig to access system fonts
  • Unified focusable? and selectable? properties so that we now have in progression: enabled? selectable? editable?
  • Added support for views in merged-cells
  • Big cleanup of every image related module


  • Added a simple skins manager in the tools menu
  • Skins are now user configurable from a Skins.jml settings file
  • Added skin support
  • Work on making IDE functionality more modular
  • Added favorites support
  • Added a new profiling-advice
  • Added prefixed advice: (advice 'jazz.ui.* ...)
  • Added debug-avice + Improved trace-advice output
  • Added a new advice function and support for runtime introspection
  • Added jazz.git.ui with a simple Git-Explorer class
  • Various improvements to the SQL workspace
  • Search dialog / Projects tab: Greatly improved response time + Everything can now be used (Whole Words, Ignore Case and even Regexp!)
  • Now standardizing the profile argument so it doesn't need to be capitalized anymore
  • Loging dialog default profile can now be specified using -default-profile
  • The minibuffer can now be hidden/shown automatically
  • Basic commands like c-a and c-e now auto exit incremental search
  • First implementation of multi-stage management 'a la emacs'
  • Added support for multiple independent stages
  • Added support for many emacs c-x commands
  • Added cataloging for colors and fonts


  • Improved ctrl-alt-i display-info to show declaration hierarchy
  • Added a pulse-caret? text-preferences property
  • Added missing tabulation for various common lisp forms
  • Modified c-a logic to be more emacs compatible
  • Improved Chapters / Hierarchy navigation with double-click, return, escape and c-g support
  • Now sorting Chapters and Hierarchy by default
  • Added support for highlighting matching characters
  • Incremental search can now be used in any text including the console


  • Added @ to remote processes
  • Recuperate from calls to crashed debuggee
  • Added an explicit Restarts palette
  • Clicking a frame in a snapshot now edits the definition
  • Started work on Swank backtrace and restarts
  • Started experimental work on a Swank debugger
  • Added support for viewing snapshot files in the debugger
  • Fixed a long-standing crash in the remote inspector
  • Now detaching from controller even on low-level calls to exit


  • Implement remote profiler
  • Unified the deterministic and the statistical profilers
  • Basic port of the classic Jazz C++-based deterministic profiler
  • Now using high performance counters in statprof
  • Statprof now handles correctly FFI calls spawning multiple heartbeats
  • Added performance counter (high resolution timers) support


  • Initial Jazz webserver re-architecting.
  • Refactored contrib.webserver, simplified interface.

2010-08-21 - Presentation at the 2010 Workshop on Scheme and Functional Programming

An article "JazzScheme: Evolution of a Lisp-Based Development System" has been submited and accepted for presentation at the 2010 Workshop on Scheme and Functional Programming.

See you there!

2010-03-22 - JazzScheme 2.3 released

JazzScheme 2.3 is now available. See Install for details on installing Jazz and Jedi.

NEW IN 2.3

  • Added -load option to load a specific module
  • Added -eval option to evaluate code after loading the kernel
  • Added -test option to run the validation suite of a product
  • Added -force option to the kernel that can be used with -compile
  • New crash handler that will output a backtrace when a crash occurs

Build System
  • Static build of libraries
  • The Jazz kernel can now be built as a library
  • Build system is now fully scriptable
  • Added an option to build executables without including the Gambit compiler
  • Added new options to build without debug environments or debug location
  • Added parallel build support specified by jobs: number-of-jobs
  • Added a -link option (objects libraries all) to the build system

  • Module require/import/export are now special forms
  • Added a validation suite for Jazz
  • Added support for public / protected modules
  • Import conflicts are now detected
  • Major simplification and cleanup of everything related to literals
  • Added walk-time argument count validation
  • Implementated runtime library access of its exported symbols
  • All Jazz exception handling now fully supports scheme exceptions
  • Printing load stack in error message when cyclic dependencies occur
  • Added override modifier to methods overriding a base virtual method
  • Replaced function special-form with lambda in all modules
  • Now supporting slots in meta classes
  • Added initial support for type-safe enumerations

Hygiene (many thanks to Alex Shinn)
  • Added support for hygienic macros using syntax-rules
  • Initial define-syntax support
  • Converted many macros to the new hygienic define-syntax

  • Added a new 'gambit' library that exports every Gambit procedure
  • Now cataloging Gambit's define-type-of- special form
  • Added an API to Gambit's structures and types
  • Added support for s8/u8/.../f32/f64 homogeneous vectors

  • Every repository and package is now automatically an alias
  • Greatly improved load time of applications

User Interface
  • Added support for merged cells in the tree view

  • Many fix to X11 so it is now in a fairly usable state

  • Irregex
    • Ported Alex Shinn's Irregex library
  • Match
    • Ported Alex Shinn's Match library
  • Statprof
    • Added support for keeping a backtrace for each registered call
  • Added base64 module (from Gambit's examples)
  • Loading of a PNG image from a u8vector

  • Catalogs are now automatically updated on save in a background thread
  • Regular expressions support in the multi-search/replace
  • Added a define-expression macro enabling user expressions to extend the IDE
  • Added basic arrow navigation in F8
  • Added a new SQL workspace
  • Started a Showcase view to showcase available widgets
  • Launch time error now get reported after IDE has finished launching
  • Made mouse copy work accross views and in plain texts
  • Added Debug With... menu item to debug using any kernel (core, debug, ...)
  • Added full-screen functionality
  • Added register-user-completion(s) to user extend auto-completion
  • Directories search is now done in a background thread
  • Every text style can now be customized in the preferences. Have fun!
  • Started work on workspaces composed of independent OS windows

  • Added support for all basic emacs commands
  • Incremental search with highlight of every occurence found
  • Added c-x c-f find-file, c-x c-F find-filename and c-x b find-buffer
  • Adding M-y cyclic-paste behavior to emacs bindings
  • An experimental implementation of paredit is available

  • Major improvements to the remote debugger
  • Inspectors now work with remote REPLs
  • Added a Show Dynamic Environment button to the Variables pane
  • Added access to selected frame local variables in REPL evaluations
  • Started work on integrating Gambit's stepper in Jedi
  • Now binding debuggee's current-input/output-port to the debugger's console
  • The inspector can now inspect Gambit structures and types

  • Started work on a full-fledged GUI designer

  • Added a new Hello World tutorial section
  • Added a FAQ


  • Prototype-based programming
  • Static link of executables
  • Finish work on the GUI designer

2009-10-19 - JazzScheme embraces its Scheme destiny!

The last of the Jazz-specific constructs, namely using 'function' instead of 'lambda', was removed from the language. The decision was made after realizing it was time that Jazz fully embraced its Scheme destiny!

We plan on continuing to evolve the Jazz language, platform and IDE to make them ever more Scheme- and Lisp- friendly.

2009-06-27 - Auphelia Technologies to use JazzScheme for their new ERP software

After an exhaustive evaluation period, Auphelia Technologies has decided to develop the backend of their new Enterprise Resource Planning product entirely in JazzScheme. Decision is still pending between Qt and JazzScheme for the desktop client but there is a definite preference at this point for using JazzScheme across the whole project.

One key element of the decision to use JazzScheme was the high complexity of the project. The project is not to create just another ERP software, but rather a complete dynamic ERP-creation platform.

On the technical side, the project will include development of the JazzScheme platform by three people over a period of about six months. Planned work includes:

  • Documentation
  • Static builds of executables and libraries
  • Module system / Hygienic macros
  • Performance / Memory / Stability
  • UI / Interface designer
  • IDE / Remote debugger and profiler

Note that Gambit's author, Marc Feeley, has confirmed his participation part-time in the project!

Various job openings for highly-skilled people where also announced. For details, see: http://lispjobs.wordpress.com/2009/06/27/auphelia-technologies-erp/

2009-01-26 - JazzScheme Publicly Released

JazzScheme was publicly released today. Note that this is a Beta release.

Information on getting and building the sources can be found here: Sources .

Consequently, the JazzScheme google group is now freely accessible. Anyone can view the discussion threads and join the group.

2008-12-24 - Closed-beta Release to the discusion group members

JazzScheme was released today as a closed-beta to the discusion group members.

The main goal of this release is to let people experiment with Jazz and the Jedi IDE and gather feedback in preparation for a public release.

Changes since the MSLUG presentation

Project Management

Project management has received a major overhaul. The result is hopefully a very flexible and intuitive to learn project management system that offers various project templates for easy learning. Only downside is that most of the tutorials on the website that where created for the MSLUG presentation are now somewhat out of date. Please take a look at them even then as they should help you get started. We will be working on and off to bring them up to date in the next few weeks.


Using new Gambit hooks, the debugger is now able to locate source code even if it is moved around. This is extremely useful for binary releases where the source code will end up in a different location than the one where it was when the compiled .o1 was generated.

Build System

A serious memory problem in the build system has been solved. Before, building Jazz could end up taking up to 2G of memory! Now, after a quick peek of 700M when linking the kernel, the whole build process seldoms takes more than 200M of memory.


*Every* call to unsafe ## Gambit primitives is now wrapped in a safe %% macro that, depending on the safety chosen in the build configuration will be expanded to either a safe call for 'debug' safety or an unsafe call for 'release' safety. In theory, no code run in 'debug' should ever crash. Note that for performance reasons, the default safety is 'release' and thus by default jazz and jedi are built in 'release'. Should you encounter a serious crash in Jedi, as the build system supports multiple configurations, you can easily build a separate 'debug' version to try and solve the problem.


An emacs bindings was added to the Jedi IDE. Although there is no objective for Jedi to ever be an emacs clone, we sure plan on integrating every nice emacs concept.

User Profile

Every user setting is saved in a 'profile'. If some of these settings are manually edited and corrupted, the IDE would fail to launch. Now, every profile setting will load safely and a generic one will be used should a problem ever occur so that in theory, no amount of corruption should ever stop the IDE from launching correctly.

Todo before the public release


  • The remote debugger is totally functional at the moment but is still missing many features
  • Common Lisp debugger through SWANK


A lot of work remains to be done documentation wise. We plan to quickly bring the documentation to at least a point where every stable method has basic documentation so that it is easy for a programmer to know if a method is 'OK' to be used or not.

2008-11-27 - Presentation at the MSLUG and closed-beta release

November 27, I will be giving a presentation of JazzScheme at the next MSLUG meeting.

This will also be the occasion for a closed-beta release to prepare for an upcoming public release.

After the meeting, I will send invitations to all JazzScheme group members to join the closed-beta. I warmly invite all of you to join in the fun!

Guillaume Cartier


Date: Thursday, November 27, 2008
Time: 7:00pm - 9:00pm
Location: Room 3195, André-Aisenstadt Building, Université de Montréal
Street: 2920 chemin de la Tour
City/Town: Montreal, QC

As some of you know, Guillaume Cartier has been working for the past 12 years on his JazzScheme system. It is a powerful and complete development environment for Scheme applications. You can read about it here:


A couple of years ago, he decided to port the whole Jazz kernel to Gambit-C Scheme and to eventually release Jazz under an Open Source License. With the near completion of X11 support, the time to do a full public release is coming very close.

In order to help spot and iron out the remaining issues for a full public release, Guillaume will be doing a "Closed Beta" release to the participants of the MSLUG. The release will take place at the MSLUG meeting on November 27th. You are encouraged to bring your own laptop, as Guillaume will walk us through the installation of Jazz and the creation of a simple application. Note that Jazz should run on Windows *and* on systems featuring an X11 server.

Thanks to Marc Feeley, WiFi Internet access will be available at the meeting, which should help with the whole process.

Once everybody is up and going with the system, we'll merrily go down the mountain to the pub and celebrate the release.

Everybody is welcome. Please spread the news around and invite friends and colleagues.

Map of UdeM campus: http://www.stcum.qc.ca/metro/images/c56.pdf


2008-11-06 - X11 Port and Debugger Update


I am very happy to report that X11 has progressed by leaps and bounds in the last weeks. A big structural change to the windowing system where Jazz now manages everything inside the toplevel windows fixed nearly all the X11 problems. This change has also unified profoundly the windowing architecture of all platforms so that all platforms should now evolve much more uniformly towards stability and completeness.

Personally, I have worked exclusively on X11 for the last 2 weeks and it felt almost as good as working under the Windows version. The only things I missed where drag & drop (we are looking into it) and faster scrolling (we are looking into using XCopyArea to implement fast scrolling on X11). There are other shortcomings like dialogs not being modal at the moment so that you can crash the system by being a smart ... and breaking the modality but those are no show-stoppers to use the system as-is imo.

As the X11 port was the main hurdle to the open-source release, this is very good news. At this point, apart from small improvements, the main task that remains is writing documentation, tutorials, ...


The other big change is that after being unsure for the last 2 years about what was the right approach to having the debugger fully understand the Jazz language, between :

  • 1) writing my own interpreter for the Jazz language and
  • 2) fully integrating the Jazz macros with Gambit

I have finally decided after discussions with Marc Feeley that 2) was the right approach and so I rewrote all Jazz macros as ##define-syntax and added full Gambit source code annotations so that now every Gambit debugging feature works seamlessly with Jazz code like :

  • precise reporting of the position of an error in the source file
  • stack backtrace with for every frame precise highlighting of the call site
  • statprof statistical profiler is now integrated with Jedi
  • ...

2008-09-26 - Public Open-Source Release Update

Now that our first JazzScheme contract is over, here is an update on where we stand.

First of all, I am very happy to say that the contract was a complete success. It proved that developing a business application in the new Gambit based JazzScheme is a viable solution. I must say that development was a charm and on top, the client loves the result!

For some other very good news, during the contract, to support development we added many missing features to the Jazz platform :

  • Kernel unit and build system is now language agnostic
  • Project management through a visual workbench
  • GUI remote debugger
  • Programmatic restarts
  • Full unicode support throughout the IDE
  • Printing support on Windows
  • Windows COM support
  • A new crash handler routine on Windows will dump a Gambit stack even on fatal crashes

Public Open-Source Release

With those new features added, we are very close to a public open-source release of the JazzScheme platform.

The key feature that still needs work is X11. Unfortunately, the student who did the port now has less available time to spend on the project as his master's degree is taking a lot of his resources. We are still both working on X11 but it may take a while to complete.

Note that the port was advanced enough that the whole IDE was 90% functional. I would guess the work remaining to be around 2-3 weeks for someone both knowledgeable in X11 and in Jazz. Personally I do not have the time required to delve into X11 but if anyone with good X11 knowledge wants to team up, it could be a fun project and accelerate the completion of the X11 port. Just let me know.

In Development

  • Jedi as a Gambit IDE with full remote debugging
  • Emacs inspired bindings for basic commands (almost complete)

2008-04-30 - Contract awarded to use the new Gambit based JazzScheme

I am very happy to announce that MetaScoop was awarded a contract to implement a full business application using the newly developed Gambit based JazzScheme.

Note that we will still be developing JazzScheme actively but with focus on more 'business' aspects like :
  • Robustness and Performance
  • Full database support on Windows using ADO
  • Printing support on Windows
  • Localization
  • Distribution of built code

We expect work on the open-source release to resume in about 2 months where at this point finishing X11 will be pretty much all that remains.

2008-04-29 - Progress update

Here's a summary of the most important developments in the last 2 months :

Build system

  • Now using pkg-config to simplify build dependencies processing
  • Added support for binary packages for a complete distribution solution


Support for the following Gambit features was added :
  • TCP/IP
  • Threading
  • U8 vectors


  • Added branch prediction to the type system for nillable types and the 'or' special form
  • Implemented a new 'meta' keyword that greatly simplifies metaclass programming


  • Many improvements on X11
  • Carbon work started up to the point where the Jedi IDE now fully loads

Web Server

Ported the Web server / framework to the new Jazz. I must say that Gambit's TCP/IP support, threads, ports and u8vectors made this port a pure pleasure.

Two new samples where developed to demonstrate the new web framework :
  • Gomoku
  • Connect-4


  • Views now support arbitrary scaling
  • Added printing support on windows
  • Ported many parts of the visual GUI designer

2008-02-04 - New build system fully implemented in Gambit

Here's a summary of the most important developments since the last update (apart from a very nice Christmas vacation with my son :-) :

Build system

A new build system was developed to automate Jazz building and deployment. It follows the usual configure / make methodology and is fully implemented in Gambit making it highly portable. See the INSTALL file at the root of the distribution for details.

  • The build will now create a 'jazz' executable file that encapsulates the Jazz kernel. Use this executable to load Jazz code, launch Jazz applications, ...
  • Under Linux, we are now using pkg-config to simplify building library depencies.

Package system

A new package system was developed to manage resources uniformly accross the development and deployment stages of a project.

  • With it, Jazz applications can be deployed as compiled binaries, source files or as a mix of both.
  • Jazz will use a sha-1 digest of the source file to automatically determine if a file should be loaded interpreted or compiled.

Generic methods

Jazz now implements generic dispatch on an arbitrary number of parameters.

Port fixes

  • View debugging tools (F8) are now fully functional under Windows.
  • Groupware compare directories and compare files.
  • Login dialog.
  • Users management.


A lot of progress was made on the X11 port which is now very close to being usable.


Ported the very nice Time Data Types and Procedures SRFI-19 to Jazz.


  • Many Gambit specific improvements related to performance and space.
  • All jazz units have now been ported to the new kernel at least enough to load correctly.

2007-11-11 - New Gambit based kernel now faster than the old C++ kernel!

A lot has happened since the last news update a month 1/2 ago. Let me try and summarize the most important developments :


As I was saying in the last message, performance was very critical as this stage as it was so far behind the old Jazz as to make the new one unusable. The benchmark I have been using is editing Window.jazz a big file with lots of syntax coloring necessitating a lot of sexpr navigation. As every Lisp related tool must be able to navigate sexpr in text, those operations are so critical that in the old Jazz they where handcoded directly in C. So keep in mind that in the benchmark results, it is handcoded C code vs Jazz code generating Gambit code.

First timing was :

Old Jazz : 0.3s
New Jazz : 28.5s

so 95x slower.

We are now at 0.17s so 167x faster than the first version and 60% faster than the old handcoded C code. Note that there is still a lot of room to make this much faster but now that performance is acceptable we are going to put performance aside for a while in favor of other priorities.

Thanks to Guillaume Germain for his wonderful statprof statistical profiler which really helped in finding the hot spots to optimize.

Type System

Jazz now supports a fairly complete and completely optional type system.

Every part of a Scheme program can now be type annotated. Note that usually, just annotating the type of the input parameters of a function will be sufficient, as the new type system will use type inference whenever possible to deduce the type of expressions.

To support the new type system, a new experimental specializer / template system is also available. Any comments / suggestions on this part are most welcome as it is unclear what is the best approach: templates a la c++, generics a la java, parameterized types, ...

Note that Jazz as a whole doesn't use the new type system a lot. I'd say that around 30 files out of Jazz's 3000+ files use the new type system. Annotating only those 30 something critical units resulted in huge performance improvements. Also note that the type annotations are purely optional and removing any of them will not change any code semantics.


The IDE while still missing a lot of functionality has become functional enough for it to become usable. I now try and use it as my main development IDE over the old Jazz's IDE.

Mainly missing from the old Jazz IDE is debugging support. We are still relying on the Gambit console. Note that this is really not painful at all as the Jazz generated Scheme code is so close to the original code that reading a Gambit stack of Jazz code is almost identical as what a pure Jazz debugger stack would look like.

Scheme Compliance

The old Jazz, although 'Scheme inspired' was never a full Scheme implementation.

Everything that Jazz was redefining from Scheme was rethought / renamed so that now I am very happy to report that Jazz is now a full R5RS Scheme (to be more precise: as R5RS as the underlying Scheme you are using is) system where any R5RS Scheme code can be run as is inside a Jazz unit or module.

If pure Scheme is used inside a Jazz unit or module, the resulting code will have no overhead and will be the exact same code. The Jazz module system will just validate at compile time that every symbol referenced exists in the underlying Scheme system and report any unresolved symbols.

Cross-Platform / X11

The Jedi IDE while not functional, is now booting completely under X11! What was astonishing was that nothing was working, and a couple changes later, Jeremie had a version where *everything* was rendering perfectly! The port of the graphical code to Cairo really payed off there. I am very happy about this new development, especially as Jeremie was able to pull this off part time while studying for his master's degree. Gratz!

Public beta release is still planned for very early 2008.

2007-09-26 - Jedi running under the new Gambit based kernel

I am very happy to report that Jedi, the Jazz IDE is now running under the new Gambit based kernel. Lots of features where temporarely commented out but basically most of the language and the library has now been ported to the new kernel.

The port of 100+ C++ classes to Gambit was very demanding at first but now the development has really become a joy. Even though the start was difficult, developing the new kernel on Gambit's extremely robust, fast and flexible architecture has now surpassed all my expentations in development speed and quality of code that could be developed with it. Cheers to Gambit!

Next steps are:
  • Complete the port
  • Optimize the new kernel to make it as fast as Gambit can be (that's fast!)
  • Port the library and IDE to Mac and X11 (this should be fairly fast at this point)
I expect a first beta, beginning of 2008.

2007-08-08 - Presentation at the lispvan

Guillaume Cartier gave a presentation of JazzScheme at the Vancouver Lisp Users Group. See Bill Clementson's Blog for a nice summary.

2007-05-28 - JazzScheme 1.0b6 available

This version is a candidate for the public release. Only bug fixes are planned until the public release. See the What's New section for details.

2007-05-14 - Work on porting JazzScheme to X11 and Macintosh started

Active work has started on porting the JazzScheme platform to other operating systems. Support is planned for the following platforms: Windows, X11 and Macintosh.

2007-05-03 - JazzScheme 1.0b5 available

This version adds a lot of support for Scheme code edition which is now almost on par with Jazz code. See the What's New section for details.

2007-04-23 - JazzScheme public beta released

First publicly available beta release of JazzScheme.

2007-01-12 - JazzScheme ported to Visual Studio 2005

JazzScheme was successfully ported to Visual Studio 2005. This is a key milestone for Jazz, as with Microsoft's release of Visual Studio 2005 Express as a free downloadable package that can be used to build C++ applications with no licensing restrictions, Jazz can now be used as a 100% free development platform for building Windows applications.

2006-12-13 - Presentation at the MSLUG

Guillaume Cartier gave a presentation of JazzScheme at the Montreal Lisp/Scheme User Group. See http://schemeway.dyndns.org/mslug for details.

2006-12-12 - Montreal company to use JazzScheme

IsaiX Technologies a high tech Montreal company, has decided to use JazzScheme for one of its top projects. Using JazzScheme, they plan on developing a real time scheduling engine for Chyma their Health Care Industry product.

2006-11-22 - Website goes live

A first version of the JazzScheme website is now live!