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!
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.
- 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 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 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.
- 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.
XML & JSON
- 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.
- 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
- 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).
- 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.