The Official jMax Phoenix Home Page

This Wiki is the official jMax Phoenix home page and web site. We decided to move the home page on the wiki itself to make easier to add news to the home page.

Latest news on the jMax development.

I am working on cleaning up the user interface a fixing quite a lot of bugs preparing the next beta. Stay tuned !!!

I read a lot of interesting discussions on scoping on puredata, and in some thread it was said that jMax has scoping. So, what's the deal ?

I decided to write a page to clarify this point.

I am a puredata external object developer, can i use my objects with jMax ? I am a puredata user, can i run my patches with jMax ? What can i do today, what will i be able to do tomorrow ?

To get some answers to the above and to similar questions, check this page.

I'll slowly add a couple of sections to this wiki: a section jMax for Puredata users, that highlight the major differences and similarities between the two system and point to the proper documentation, and a section jMax for Puredata object programmers, to help Puredata object programmers to understand the main differences and similarities between the APIs of the two systems.

Actually, more a symbolic milestone than a real, usable, result: the current committed code base is able to load simple puredata patches; just to let you know about the progress in development :→.

I created a | troubleshooting oriented FAQ page to list the common problems and errors that you may find trying to use jmax.

jMax Phoenix is a challenger in a market where there is a well established and mature standard. In order for jMax Phoenix to be widely adopted and used, a way to preserve the users investments and experience must be provided.

So, here is the big project i worked in the last month or so: PD compatibility; the project progressed enough to make me confident in talking about it.

The first phase is external object source compatibility: the objective is being able to compile “as such” all the sources that respect the PD external objects HOWTO and having them magically converted to jMax objects. Objects using other functionalities may works or not, depending on the functionality in question. Surely objects that have a graphic implementation will have to be partially rewritten, because the graphic architecture of jMax is radically different from the PD one. The objective is to integrate the whole pd basic and extended object set in the jMax 1.0 release.

The second phase is being able to read pd patches and abstractions; once the object set is there, this should not be very complex, because jMax can already read the MAX/ISPW and MAX/FTS format pd is based on. Some extension will be needed at the graphical level, in order to be 100% compatible: some graphical objects are missing and jMax do not currently provide the controller-in-parent functionality.

If you are interested in this evolution, and you are patient, i am looking for beta tester. The first implementation should be ready in one month or two.

I am currently working on the core jMax object system, adding some extension to allow an object programming model similar to the Max/ISPW or PureData, like adding inlets and outlets in the object initialisation phase as an alternative to using the more complex meta class model.

An other interesting point is the ability to have “overloaded” classes: essentially the idea is that the same object name may correspond to different “external objects”, depending on the arguments; for example, ”+ 10” and ”+ 10.” may correspond to different implementations, one for integers and one for floats. The interesting point is that the day someone wants to add a set of objects dealing with complex numbers, for example represented by a 'complex' message with two arguments, it would be easy to add a ”+ 10 i 20” object adding complex number; this complements well the type flexibility jMax have (remember, jMax code do not make assumptions and do not depends on available types). This overloading extensions provide also an extension of the meta class API, that make things simpler for developers.

It is purely a matter of extensions, keeping total backward compatibility with the existing code.

Of course, one of the goal of these changes is to make easier for a PureData programmer to write objects for jMax. The mail goal, however, will be clear in a few weeks.

The changes will be documented in this wiki, little by little. The object API documentation will be reviewed, and the new functionalities added. Sections regarding features that are not yet availables with be marked with the version they apply to.

jMax Phoenix change license: the original license was a modified GPL. After the agreement of all the copyright holders, we decided to change the license to LGPL, to easy the adoption of jMax, making it compatible with commercial products and environments.

Note: since the alpha 0.5 snapshots never worked, i merge the announce of the 0.5 beta 1 with the previous text on the alpha. If you read already the announce on the alpha, read again for more details. 0.5 beta 1 solve the linking problem that prevented jMax to works on a file system location different from the build location.

I am pleased the announce the release of jMax Phoenix version 0.5 beta 1, that include a couple of nice step forward for the jMax Phoenix project.

First of all, to simplify versions and tracking on multiple platform, we added a release naming to the revision numbering we used up to now. A release will go thru multiple revision (build) number, and progress, like for other projects, thru a number of alpha, beta, rc, and GA versions.

The first jMax release is called 0.5, like in one half, to say it is still half baked :→. It is a beta now, because feature development is almost frozen (some plumbing work related to bug fixing is still going on). You'll find the download files in the usual sourceforge project site, under the 0.5 Beta 1 folder.

First step, support for LADSPA plugins: LADSPA plugins present on your platform are by default automatically loaded and transparently imported as jMax Phoenix objects. Check this sections for details on how LADSPA plugins are handled.

In order to work with the huge number of objects availables thanks to LADSPA integration (more than 600 with a vanilla Ubuntu Studio 9.04 installation), we added an object browser; the new user interface component is not yet documented, but is very intuitive to use: present the available objects in a list, where you drag a row to an open patch editor to instantiate the object. A search box allows to select objects by content, and a couple of popdown menus allows to select on the object category, package or author. By the way, the patch editor accept now also dragging of text from other application. Such a text will interpreted as a single object description, and the corresponding object will be created.

Please note that an other new functionality is becoming to surface: a View menu that allows to select which part of the user interface are shown. Unfortunately, you'll got the menu only before opening a patch editor, and than it will disappear; the problem need some changing in the way menus are handled, so it require a few days of work in order to be fixed.

Second step: platforms: the 0.5 beta 1 run on Mac OS X Leopard, Linux 32 and Linux 64 bit and Windows, based on the use of cygwin. Snapshots for Linux 64 bits and Mac OS X have been uploaded. The 32 bit Linux and the Windows snapshot will be upload next week. Please notes that snapshot for different platforms may have different revision number; that is normal.

The Mac OS X version is still kind of rough: it is lightely integrated with the Max OS X environment, and it have to be runned from the command line (follows the Linux instructions). More integration will slowly added in the next weeks. jMax should run on Leopard and Snow Leopard, and require Java 6 configured as default virtual machine. This also means that it will never run on Tiger, sorry about that, but no Java 6 is available for Tiger.

LADSPA plugins can be used also on Mac OS X.

Please note: this version is configured to use the default portaudio input output, that should be a reasonable default in each platform. This release use portmidi for midi, but the midi device is not yet configured in the configuration file. You can configure it following the documentation, or wait for the next snapshot.

A final warning: this is a very very first release of both LADSPA integration and Mac OS X porting: it is a snapshot, it is probably unstable, and probably have problems that we have not yet found. We are looking for testers !!!!! Please, contact us if you try to use jMax Phoenix and if does not works as expected, and also if it does works as expected.

The documentation is this wiki is now almost completed.

Packaging of abstraction or external object libraries and applications in jMax Phoenix packages is fully documented. The configuration system is also fully documented, including the way to define personal user interface layouts.

We are working on Windows and Mac OS X snapshots. A quick status report: the first windows version will be an experimental snapshots based on the use of the cygwin Unix emulation layer on Windows. It is currently working, with audio, but without midi. Midi will come later, once i am able to build the portmidi library on cygwin (there works going on in the portmidi community to address this point). Some cleanup is still needed, as a couple of windows specific scripts that are being developped.

The Mac OS X version is almost working: some blocking bugs needs to ironed out in audio i/o, but it should not take a long time.

The two versions will be released together with the next snapshot.

This snapshot introduce a number of simplifications in the configuration file syntax; when you start do document something, you end up cleaning up what you are documenting, because weaknesses and inconsistencies become apparent. There is no change in the documented features, but what was not yet documented will be simpler to describe, and to put in place.

On an other side, it introduce a number of changes in the build structure, to make it more portable, in preparation for Mac Os and Windows port. The old veclib has been radically simplified, suppressing the old complex macro system, and making it simpler to port and to maintains.

Last but not least, i am finally equipped with a 32 bit Linux installation, so this snapshot has been uploaded in 32 and 64 bit versions. Let me know if they works.

Just uploaded revision 160, that finally drop the tcl configuration system and adopt XML for all the aspects of the configuration. The wiki documentation it has been updated, even if it is not complete, especially about writing packages. Be patient, full documentation will be up in a week or two.

This snapshot is the baseline for the first planned public release of jMax Phoenix and for the Mac OS X (and hopefully Windows) port.

WARNING: there is a bug in revision 160 that prevent jMax to start unless there is an xml file in your home directory called .jmax.xml. This is not the intended behaviour, the personal configuration file is optional. Snapshot 173 fix the problem.

jMax is migrating its configuration system from tcl to XML. The reason is the power a declarative configuration system provide, and the simplicity of the implementation, once the basic bricks are in place.

Next snapshot will migrate to xml the I/O configuration, and a part of the bootstrap process. On the occasion, it will simplify the configuration model, that was initially designed for networked configurations, where a single installation could be used by multiple heterogeneous machines; since this is not any more the reality (today disk space abound, and each machine will have its own installation, even on a big installation), it was a good occasion to radically simplify the model, leaving the room to add other functionalities when and if needed.

The configuration documentation has been updated in the wiki. The documentation for the old tcl configuration is not online anymore: everybody interested should switch to a newer snapshot as soon as possible (starting from rev 160).

The new configuration syntax is designed to be forward compatible with future extensions.

You can find older project new in this page .

The document is stored in this wiki, and include the following sections:

• Release notes of the various snapshots and releases.

• General discussion about jMax history and motivations
• Documentation for the final user
• Documentation for the package developers (extensions, objects, etc)
• Documentation for the core developer
• A design wiki hosting brainstorming and design activity

• A roadmap/todo page for the project management

• A troubleshooting oriented FAQ

• Documentation on jMax for Puredata users
• Documentation on jMax for Puredata object programmers .

You can check the project sourceforge site, at http://sourceforge.net/projects/jmax-phoenix/ You'll find the sources, the project mailing lists, and the binary releases.

You can contact us at contact@jmax-phoenix.org, or in the jMax developer mailing list on sourceforge.