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:

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.
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!)
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.


  • 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 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.


  • 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.


  • 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.


  • 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.