JUCE - Le Bottin des Jeux Linux



Title: JUCE Type: Tool
Genre: Development Status:
Category: Development ➤ Framework & Tool Commercial:
Tags: Development - Autres outils - Framework & tools - C/C++ Demo:
Released: Not Tracking Package Name:
Date: Extern Repo:
License: Most modules : GPL v2+ & AGPLv3 / juce_core module : ISC / Others : Commercial Deb Repo:
View: Package:
Graphic: Binary:
Mechanics: Source: ✓
Played: Single PDA:
Quality (record): 5 stars Quality (game):
Contrib.: Goupil & Louis ID: 14356
Created: 2014-06-26 Updated: 2014-11-08


[fr]: Une bibliothèque C++ pour le développement de logiciels multiplateforme [en]: An all-encompassing C++ class library for developing cross-platform software


Trailer / Gameplay [en] / [en] / [fr] :


Website & videos
[Homepage] [Dev site 1 2] [Features/About] [Screenshots] [Videos t t t g g g] [WIKI] [FAQ] [RSS] [Changelog 1 2]

Commercial : (empty)

• (empty)
Technical informations
[Open Hub] [PCGamingWiki] [MobyGames]

Devs (Julian Storer [fr] [en]) : [Site 1 2] [twitter] [Facebook] [YouTube] [LinkedIn] [Interview 1 2]
Game : [Blog] [Forums] [twitter] [YouTube]

On other sites


News / Source of this Entry (SotE) / News (SotN)

Description [fr]

Une bibliothèque C++ pour le développement de logiciels multiplateforme, par le studio Raw Material Software ltd (Julian Storer).

La bibliothèque JUCE

JUCE (Jules' Utility Class Extensions) est une bibliothèque de classes C++ englobante pour le développement de logiciels multiplateforme (Mac OSX, Windows, Linux, iOS, Android).
Elle contient à peu près tout ce que vous êtes susceptibles d'avoir besoin pour concevoir la plupart des applications, et est particulièrement bien adaptée pour la construction d'interfaces graphiques hautement personnalisées, et pour la manipulation de graphiques et de sons.

Je suis fier d'avoir reçu beaucoup d'éloges au fil des ans pour la qualité du code, aussi je vous encourage à plonger dans son code et à jeter un oeil par vous-même - nous espérons que vous aimerez ce que vous y trouverez !

Histoire et développement

JUCE est essentiellement l'oeuvre d'un seul homme, ayant évoluée à partir de classes d'utilitaires qui ont commencés à s'agglomérer en 2001 - dérivées du développement de diverses applications audio telles que Tracktion (un séquenceur, dans le Bottin).

Julian Storer est le seul développeur et propriétaire de Raw Material Software ltd, qui publie cette bibliothèque.
La bibliothèque a été rendue open source en 2003, et est exploitée commercialement depuis 2005.

Description [en]

The JUCE Library

JUCE (Jules' Utility Class Extensions) is an all-encompassing C++ class library for developing cross-platform software.

It contains pretty much everything you're likely to need to create most applications, and is particularly well-suited for building highly-customised GUIs, and for handling graphics and sound.

I'm proud to have received a lot of praise over the years for the quality of the codebase, so would encourage you to dig into the code and have a look for yourself - hopefully you'll like what you see!

History and Development

JUCE is essentially a one-man endeavour, having evolved from utility classes that began coalescing back in 2001, as a spin-off from the development of various audio applications such as Tracktion.

Julian Storer is the sole developer and owner of Raw Material Software ltd, which publishes the library.

The library was first open-sourced in 2003, and has been sold commercially since 2005.

Supported Operating Systems and Compilers

JUCE can target the following platforms:
Applications and VST/AudioUnit/RTAS/NPAPI plugins can be compiled with Xcode.
Applications and VST/RTAS/NPAPI/ActiveX plugins can be built using MS Visual Studio. The results are all fully compatible with Windows XP, Vista or Win7/8.
Applications and plugins can be built for any kernel 2.6 or later.
Native iPhone and iPad apps can be built with Xcode.
Android apps can be built using Ant and Eclipse, using the Android NDK.

The library shields you from as much platform-specific detail as possible, so if your C++ is portable, then you should be able to simply re-compile your app to run it on other OSes.


JUCE contains over half-a-million lines of painstakingly hand-crafted code, and hundreds of classes.. It's hard to summarise all the features, but these are some of the main categories.

There's also a complete set of API documentation, where you can browse through all the available classes.

☑ High Quality Code
In designing JUCE, I've tried to make it:
• Literate
Class, method and variable names are clear, self-explanatory and consistent. It's vital in such a large library that when you look at a class, it should be obvious how it works; and when you use a class in your own code, the result should be as readable as possible. The best way to achieve this is by using well-written names.
• Coherent
A library needs to be predictable enough that once you've got a feel for the way things are arranged, you can navigate around it without any surprises. If you need to do a particular task, you should be able to guess what the classes to do it might be called and find them quickly. (Having a single person write the entire library helps with this!)
• Cross-platform
Any behind-the-scenes platform-dependent code is kept away from public view and implementation details are hidden. When you include JUCE header files, they only include pure C++ classes, and won't pull in any OS-specific headers. Wherever it's possible to use a pure C++ technique instead of native functionality, I've done so.
• High Quality C++
Having been a professional C++ coder for 20 years, and having studied all the available C++ guru literature, I think I'm finally starting to get the hang of it! Every class in the library is intended to be a good example of the best possible coding practices – so if you spot anything dodgy lurking in there, don't hesitate to let me know!

☑ Modular Architecture

The library is divided into sub-modules, covering:

• juce_core - fundamental classes for collections, threading, system information, networking
• juce_events - message-loop dispatch classes
• juce_data_structures - high level data structures for active trees and properties
• juce_graphics - 2D rendering engines, image format handling and font functionality
• juce_gui_basics - core GUI classes
• juce_gui_extra - more esoteric and niche GUI classes
• juce_audio_basics - basic audio and MIDI data management classes
• juce_audio_devices - cross-platform audio i/o classes
• juce_audio_formats - audio file format reading & writing
• juce_audio_processors - audio plugin hosting
• juce_audio_plugin_client - audio plugin client wrapper
• juce_audio_utils - extra audio helpers and GUI classes
• juce_cryptography - a range of simple crypto classes for RSA, Blowfish, MD5, SHA, etc
• juce_opengl - cross-platform embedding of openGL, and a shader-based 2D rendering engine
• juce_video - video playback and capture classes
• juce_box2d - makes it trivial to add the box2d physics library to your app

You can choose to build with a subset of these modules, depending on your app's requirements.

☑ Core Classes

• Versatile container classes.
• A powerful string class which can convert between UTF-32, UTF-16 and UTF-8, std::string, NSString, etc
• A comprehensive set of file, directory and I/O stream classes, including streams for files, URLs, memory, buffering, built-in zlib-based compression, and zip-file handling.
• A full set of cross-platform threading and multitasking abilities: threads, synchronisation, events, thread-pools, process control, etc.
• A wide-ranging set of messaging classes provides many options for event-based development: listener and broadcaster classes, timers, asynchronous callbacks, inter-application messaging, and much more.
• Many utility functions and classes for data conversion, time and date, atomic operations, maths functions, random numbers, etc.
• The ValueTree and Value classes provide a very powerful general-purpose data structure which provides change notifications and automatic undo/redo support.
• A lightweight, low-overhead Javascript interpreter

☑ User Interface

• A large basic set of components including all the usual suspects: buttons, combo boxes, text editors, listboxes, treeviews, tables, viewports, sliders, tabbed boxes, etc.
• A look-and-feel system allows the look of various UI elements to be changed dynamically, and customised by an application.
• All components can have arbitrary affine-transforms applied to them.
• OpenGL support makes it easy to have openGL running inside a JUCE component. There's also a complete 2D rendering engine implemented with openGL shaders, so that 2D graphics and components can be mixed with GL 3D content.
• Movie-playback support allows video to be embedded and controlled through a platform-independent class (on OSes which provide video decoding functionality)
• Video camera capture makes it easy to preview and record from webcams.
• Multi-touch input support on iOS, Android and Windows 8.
• Keyboard input can be managed in a range of ways, from intercepting keys directly to using a key-mapping set to redirect keystrokes to automatically-invoked application level commands.
• Internal drag-and-drop within the same application allows versatile drag-and-drop logic to be acheived, with effects like semi-transparent icons, snapping back when released, etc.
• External drag-and-drop of files and text can be made to and from other applications.
• Popup menus and menu bars can contain custom components, and can be used to automatically trigger application commands, display appropriate key shortcuts, and much more.
• A set of file-browser components can be used to show either an entire file open/close dialog with embedded preview, or any subset of this, such as a navigable file list.
• Lots of ready-made UI components are included for specialised purposes like splash-screens, editing a set of key-press mappings, choosing audio device settings, selecting colours using a HSV colour picker, a clickable MIDI keyboard, lassoing objects, etc. All of these can be subclassed and customised, of course.
• A set of classes allow components to be positioned using expressions which describe their layout in terms of other components or markers.

☑ The Introjucer

• The Introjucer is JUCE's project management tool. It's open-source and you can build it from the source-code included in the JUCE repository.
• Use it like an IDE to build your project, adding source files to a tree, and editing the platform-specific settings for the various compilers that you want to target.
• Once created, your project can be automatically exported as a bunch of ready-to-run projects for Xcode, Visual Studio, Linux make, Android Ant or Code::Blocks.
• A set of wizards make it easy to create application or plugin projects.
• Integrated code editor.
• As well as generating projects, the introjucer will also convert any binary resource files in your project to C++ source-code, which is automatically included in the generated projects.
• Includes a utility for downloading the latest version of JUCE without needing to use the GIT.
• Integrated GUI component builder application allows simple UI components to be designed visually, adding from a palette of standard or custom JUCE components, and graphic operations.

☑ Graphics

• Image support for 24-bit RGB and 32-bit ARGB images.
• All rendering is sub-pixel accurate and anti-aliased.
• Rendering engines are implemented as: software-based CPU rendering, CoreGraphics-based, or openGL-accelerated.
• Built-in support for loading JPEG, PNG and GIF files. JPEG and PNGs can also be written.
• Image loading utilities make it easy to incorporate images in your app: an image cache can be used to store recently used images and avoid keeping multiple copies of the same one; images can be loaded from memory of from any kind of file stream, or just directly from a filename.
• Easy embedding of images into C++ code using either the Introjucer or BinaryBuilder makes it simple to add resources in a platform-independent way.
• Geometric paths and shapes can be created and manipulated with the Path class.
• Many helper functions and classes for geometric primitives - lines, rectangles, points, rectangular regions, affine transforms, and more.
• Gradient fills can be linear and radial, with any number of intermediate colours
• All drawing operations can have arbitrary affine-transforms applied to them.
• A set of "drawable" classes allow graphs of drawable elements (e.g. paths, text, images) to be built up and drawn as a unit.
• Importer for simple SVG files, converting them into juce Drawable objects, ready for further manipulation or rendering.

☑ Audio

• Audio driver classes provide an abstract audio device layer, which transparently supports ASIO, WASAPI, DirectSound, CoreAudio, iOS Audio, ALSA, JACK and Android devices.
• Audio device manager class makes it simple to load/save a user's audio and midi device settings between sessions, or to choose an appropriate default device for the system.
• Ready-made UI components provide UI for selecting audio and midi device settings.
• A set of integrated audio file format readers and writers include support for WAV, AIFF, Flac, Ogg-Vorbis, Windows Media codecs, CoreAudio codecs, MP3 reading.
• A set of audio stream classes allow audio graphs to be constructed and played - types of audio filter include wave file readers, sample-rate converters, mixers, and tone generators.
• A Synthesiser class allows simple creation of polyphonic synthesisers, which can be easily driven by midi input using the midi classes.
• On Mac and PC, a cross-platform Audio CD reader allows CD audio to be extracted as easily as reading any other audio file.
• Audio-CD burning is supported for Mac and PC.
• Various DSP utilities - e.g. SIMD-accelerated vector float operations; audio data format conversion utlities; IIR and reverb effect classes.


• Midi input and output support, including support for creating virtual midi devices on Mac and Linux.
• Midi message wrapper classes make it easy to manipulate midi without having to set the bytes directly.
• Midi buffer classes provide efficient collating and editing of midi streams.
• Midi keyboard state objects will monitor a midi stream and provide information about the state of a virtual keyboard. A customisable on-screen keyboard component is provided.
• Classes for merging and re-timing midi input streams to synchronise with audio streams.
• Support for reading/writing standard midi format files.

☑ Audio Plugins

• The audio plugin wrapper classes let you build a single module that functions as a variety of plugin formats - currently it supports VST (PC, Mac and Linux), AudioUnit (Mac), RTAS and AAX (PC and Mac).
• Audio hosting classes are provided for loading and running AU and VST plugins inside your JUCE app.
• Whether you're writing a plugin or loading a third-party plugin, the same base classes are used, so you can easily embed your plugin code into a stand-alone application, or load other plugins into your own plugin.


• Fast, clean, fully-integrated XML and JSON parsers. XML supports supporting entity expansion, and external entities.
• XML structure classes make it easy to use XML objects as general-purpose data structures in your code, with quick methods for interpreting attributes as various numeric types other than strings.
• Because the XML parser is available throughout the library very cheaply, many other classes make use of it to provide quick and easy ways to use XML data – e.g. the URL class has a method to read and parse the contents of an internet URL that contains XML.
• A 'juce::var' variant class can mirror javascript object types, and is used to implement JSON data structures (as well as having various other jobs in the library)

☑ Application Utilities

• Simple cross-platform application startup/shutdown (although Juce can also be used to build plugins and DLLs with a custom entry/exit points, and command-line utilities with a traditional main() function).
• Classes for language-localisation of string constants, using a simple translation file format.
• Undo/redo support using an undo manager and undoable action classes
• Base classes for file-based document handling, to handle all the logic involved in loading/saving documents, knowing when they are altered, keeping track of recently opened files, etc.
• Versatile set of classes for managing a set of named application commands, which can be triggered automatically by menus, keystrokes or buttons. A powerful command-target structure gives flexible control over the dispatch of commands, and ready-made UI components allow sets of key-mappings to be edited and stored.
• Property file support makes it very simple to store named values in a settings file for persistance between sessions. All platform-specific details about where this file should be stored are handled automatically.
• A global logging object can be assigned, which is takes any output from Juce's internal logging as well as the application's log. A pre-made logger class is provided to write to a file, but custom ones can be added.

☑ Networking

• Input stream classes to handle downloads via HTTP and FTP.
• URL parsing.
• Cross-platform low-level sockets.
• An inter-process communication abstraction layer allows communication channels to be set up using either sockets or named pipes, to either a local or remote machine.
• MAC and IP address detection.

☑ Cryptography

• Large prime number generator
• RSA Key generator and encrypter
• BlowFish codec
• MD5 & SHA hashcode generation

☑ Browser Plugins

• The browser plugin wrapper classes let you build a single module that functions as an NPAPI (Firefox, Safari, etc on Mac/PC), and ActiveX (Internet Explorer).
• Javascript classes let your plugin communicate with the javascript running on the webpage that's hosting the plugin.

☑ Miscellaneous

• Support for as much C++11 functionality as possible without breaking cross-platform compatibility. E.g. nullptr, move-constructors, etc are used and implemented on compilers that support it.
• A range of messaging and event-handling classes for timers, asynchronous callbacks, listener/broadcaster patterns, etc.
• ZIP file format parser can decompress and create zip files.
• 128-bit GUID generator.
• Various platform-specific utilities, e.g. registry read/write functions on Windows; NSString converters on the Mac.
• High-accuracy performance counter class allows timing of code sections and averaging over multiple runs.
• Unit-test framework.