Softpedia >Mac >Multimedia >Praxis LIVE >  Changelog

Praxis LIVE Changelog

What's new in Praxis LIVE 5.6.0

Jun 6, 2023
  • PraxisCORE:
  • Added root:custom (Custom root), a recodeable root type. This is part of moves to finish making everything recodeable. Using the @Driver annotation on a proxy interface it's possible to drive the root and its contained graph of components from an external callback. See use of this in the code roots testsuite test - more info to follow.
  • Improved root delegate API and thread context, with some concurrency improvements and monotonic clock fixes that should benefit all root types. Ensure pending calls are handled when a root is terminated.
  • Updated libP5X to 0.353.0-beta-4 and LWJGL 3.3.2, with fix for memory leak when stopping and restarting video pipelines.
  • Updated Ivy to 2.5.1 (security update - fixes warning, although never exploitable in PraxisCORE code)
  • Updated JNA to 5.13.0.
  • PraxisLIVE:
  • Updated base IDE to Apache NetBeans 17.
  • Added container actions to the scene background popup menu - access to code editing for custom root, but also any actions exposed by roots or custom containers.
  • Speed up project builds at UI side by ensuring UI poll is triggered on call receipt (response) rather than on timer.
  • Ensure root annotations are set in graph build (eg. show all properties not being set on load).

New in Praxis LIVE 5.5.0 (Jan 29, 2023)

  • PraxisLIVE v5.5.0 adds some key features in our evolution towards v6. These include sharing base code across components, function controls bound to methods, and an async API for calls and tasks.
  • The IDE is updated to be based on Apache NetBeans 16, with support for JDK 19. OpenJDK 17 LTS from Adoptium is still included in all OS specific bundles. Use the zip download to run with other JDKs or architectures.
  • Windows, macOS and Linux packages are now all built using NBPackage. The Windows and macOS installers are signed by Codelerity. We are no longer providing AppImages for Linux, but providing both DEB and RPM packages.
  • Key changes:
  • Shared base components:
  • It's now possible to share base component code across multiple components in a graph. Right-click on a component and select Create shared base. You can then duplicate the component (CTRL-D) and update all instances at the same time. Individual component code can still be added to extend or override the base component features.
  • The fast edit action (SHIFT-doubleclick or SHIFT-RETURN) will open the base component code for editing as long as the component has not extended the base code.
  • As a side effect of changes for base components, properties, controls and ports no longer have to have a unique index. They are sorted by index then alphabetically. This allows for code such as @In(1) PImage in1, in2; or @P(1) @Type.Number(min=0, max=1) double x,y,z; to work.
  • An important limitation on the current shared base component support in the IDE is that copy & paste of components across different graphs will not copy the shared base code - you must copy that in place manually first.
  • Function controls and value mapping:
  • It's now possible to create function controls by annotating a method in a component with @FN.
  • This is most useful when used with the Async API (below) to call a component in another graph to process data for you.
  • As part of this support, mapping between Java types and PraxisCORE Value types has been improved. The various casting methods such as d(..) and s(..) have been deprecated and replaced with upper case (D(..) and S(..)) equivalents with improved behaviour. There is also V(..) for converting from Java types to Value.
  • Async calls and tasks:
  • There is now a basic Async API for making control calls where you want the return value, as well as support for arbitrary background tasks. Methods return an Async object that currently must be polled for the result. Store the async object in a field marked with @Persist to ensure it survives code changes. Further improvements are underway here.
  • Calling a function control:
  • Call a function control using ask(..)
  • An async task:
  • For basic tasks which don't rely on properties or data of another component, you can also async(..) that will run the provided code in background thread. Be careful to pass in all required data in the first argument and not access any component data in the background thread!

New in Praxis LIVE 5.4.0 (Jan 29, 2023)

  • PraxisLIVE v5.4.0 adds support for recodeable containers. This is the first visible part of much broader underlying changes.
  • The IDE is updated to be based on Apache NetBeans 12.6, with support for JDK 17. OpenJDK 17 from Adoptium is now included in all OS specific bundles (except the Arm AppImage which includes BellSoft Liberica.
  • Windows and Linux packages are now built using NBPackage, a DEB package is again provided, and the Windows installer is signed by Codelerity.
  • Recodeable containers
  • A core:container can now be recoded. Additional controls and ports may be added. The children() method returns a list of all child IDs. It's possible to send messages to a range of child components from a control or port.
  • Further capabilities for coding containers and roots are under development.

New in Praxis LIVE 5.3.0 (Sep 29, 2021)

  • PraxisCORE runtime:
  • Added support for recodeable proxy interfaces. The interface reference is carried across code changes and automatically wraps the implementation so that the reference can be safely passed to other code while remaining updateable. See usage instructions below for more.
  • Added support for persistent fields that retain their value across code changes but are not automatically injected. For select and careful use!
  • Added support for reference providers in @Inject annotations so that arbitrary types can be injected while controlling Ref handling in a central place (eg. in shared code). See below.
  • Added a default reference provider, with initial support for List, Set and Map. These can now be used directly as an injected field type - eg. @Inject List lines. They are implemented by ArrayList, LinkedHashSet and LinkedHashMap respectively. This can be overridden by providing a custom provider.
  • Added a basic logging provider to log to System.err when running from CLI.
  • FIX : ensure JLine terminal IO doesn't break when hub is restarted by splitting out and persisting the terminal IO across runs.
  • PraxisLIVE IDE:
  • Updated base IDE to Apache NetBeans 12.4, with support for JDK 16.
  • Updated bundled JDK to JDK 16.
  • Proxy interfaces:
  • Proxy interfaces are defined by fields, and are most easily used with lambdas or method references. Unusually for PraxisCORE annotated fields, the value requires initialization.
  • It's important to be aware that the initialized value of the field will be wrapped by the proxy before init() or any other code is called. Setting the field value after this point will not work as expected.
  • It's also important to note that the interface will be called on the root thread, blocking the calling thread. This makes it safe to call functions and send messages. Support for running on the calling thread will follow in a future release.
  • Persistent fields:
  • Persistent fields allow for field values to be carried over from one iteration of code to the next. Unlike injected fields, persistent fields are not automatically set. They are most useful for temporary values.
  • Persistent fields are reset to default values (eg. 0 or null) when the root is restarted, unless the autoReset value of the annotation is set to false. Like Ref values, any AutoCloseable values will be closed when removed or reset unless the autoClose value of the annotation is set to false.
  • Inject Ref providers:
  • Ref providers allow for custom field types to be injected without requiring the field itself to be of type Ref. Instead, a Ref.Provider class, usually in shared code, can manage initialization of the Ref in one place. All of the features of Ref (except async) can be used in the provider to control what happens on reset and disposal.

New in Praxis LIVE 5.2.0 (Sep 29, 2021)

  • PraxisCORE runtime:
  • Support shared, rewritable code across components within a single root.
  • Sources for shared code are stored as a map property on the root component. All code is in the SHARED package.
  • Any component that imports shared code will be automatically recompiled whenever shared code changes.
  • Breaking changes or deletions of shared code in use will fail.
  • Data ports can pass shared types between components.
  • NB. As part of this change, the full class name of component code has changed to accommodate compiling multiple
  • components at a time. This shouldn't cause major problems.
  • NB. As part of this change, the module providing audio and video root components changed. This shouldn't cause
  • major problems.
  • Provided field for graphics object and easier access to underlying Processing graphics in video:gl:p2d and
  • video:gl:p3d based components. Use g to access PGraphics wrapper, g.unwrap() to access Processing
  • PGraphics and g.unwrap().parent to access PApplet. NB. the underlying Processing graphics may change in
  • every call to draw() due to reuse in the pipeline.
  • Added signal traps for child processes when running from terminal so that children aren't terminated before
  • parent.
  • FIX : incorrect info being reported for mapped ports on core:container. (The IDE may still show the wrong info
  • momentarily - to be fixed).
  • PraxisLIVE IDE:
  • Added UI and code editor support for shared code in the graph editor (see guide below).
  • Added a basic action in the project popup menu to embed the PraxisCORE runtime, along with an optional JDK, inside a project for standalone running and distribution. More options for exporting projects will be added in due course. Standalone projects still support live code updates, distributed hubs, and the full range of command line options including --interactive.
  • Update of nb-javac library, and changed download and integration from upstream.
  • Using shared code:
  • To access the UI panel for shared code, right-click on the graph background and toggle Shared Code.
  • To create a new shared code type, right-click on the SHARED folder and select New Type.... The name must be a valid Java type name. A class will be created by default and opened in the editor. It can be changed from class to interface, enum, etc. if required.
  • To access shared code from a component's code, add an import
  • Every time you edit and save a shared code file, all dependent components using shared code will be recompiled and updated atomically. If a code edit or type deletion causes a compilation error in the shared code or any component, the old iteration of code will continue to be used.
  • Updating the code of a component using shared code will not cause other components or shared code to be recompiled (components continue to be isolated in separate classloaders that have the shared code as a parent).
  • TIP : You can CTRL-click any shared code type or method to open it in the editor.
  • Just like with normal component code, saving the code updates the components in memory - make sure to save the graph or project to disk!

New in Praxis LIVE 5.1.0 (Feb 2, 2021)

  • PraxisCORE runtime:
  • Support for running OpenGL(ES) projects on Raspberry Pi and other ARM devices. The default OpenGL renderer uses OpenGLES on all ARM devices. OpenGL2 can also be chosen explicitly on the Pi. More info below.
  • Ability to add libraries from the Maven Central repository to projects, including resolution of transitive dependencies. Libraries are downloaded and (currently) cached external to each project. Further enhancements are planned in this area. Each library is referenced using a PURL or Package URL. More info below.
  • Added commands for libraries support that can be used in interactive CLI mode, including libraries-all for querying all in use libraries including transitive dependencies, and libraries-path for showing the local file locations of libraries.
  • Updated GStreamer (gst1-java-core) and JNA libraries - more efficient across OS, and support for MSVC build of GStreamer on Windows.
  • Default location of GStreamer on Windows now queried from environment variables - should usually work correctly out of the box in most cases.
  • Added initial JLine-based Terminal IO when working in interactive mode. Supports command history, multi-line editing and coloured output.
  • FIX for server resources not being found with distributed hub, due to resource resolver not being correctly configured when working with server enabled.
  • FIX for video playback across network not working correctly and not allowing seeking.
  • FIX for some settings, including GStreamer settings, not being correctly persisted or visible to projects.
  • FIX null pointer in MIDI support when no device selected.
  • PraxisLIVE IDE:
  • Added basic UI support in the libraries section of project properties for adding Maven Package URLs. Imported libraries will now be included as individual references, and added to a visible folder in the project. Updated editor support uses library path from runtime.

New in Praxis LIVE 5.0.0 (Sep 22, 2020)

  • v5 is a major rewrite of both the core runtime and the IDE. Much legacy and deprecated functionality has been removed. All of PraxisCORE has now been rewritten around the new base actor system introduced in parallel in 4.4.0. PraxisCORE is now built on top of the Java module system, rather than the Apache NetBeans platform (the PraxisLIVE IDE is still based on Apache NetBeans). The build for PraxisCORE has been moved to Maven, and individual modules will be deployed to central for re-use in other projects.
  • Both PraxisLIVE and PraxisCORE require at least Java 11 - an open-source Java 11 JDK from AdoptOpenJDK is included in the binary packages.
  • PraxisLIVE now supports running multiple projects at once. Distributed hub support has moved from the IDE into PraxisCORE, and is configured separately for each project. The default project configuration will run audio and video roots in separate Java processes.
  • The PraxisCORE runtime is included in the praxiscore folder inside the IDE. It can be copied out and run from the CLI for networking or project running, or embedded inside a project to make it standalone.
  • Video support is now based on libp5x, a modularised fork of Processing that uses LWJGL for OpenGL rendering.
  • Audio support is now based around JAudioLibs Pipes v2, which is also available as a standalone library including all the unit generators available in PraxisCORE. (Pipes Graph replicates much of the built-in functionality of the PraxisCORE audio code).

New in Praxis LIVE 4.4.0 (Sep 22, 2020)

  • PraxisCORE runtime:
  • Core:
  • New base module providing simpler and more robust base root class and other utility classes. The new root implementation is currently used by generic data patches root:data and internal services. These changes will allow for removal and replacement of a lot of remaining legacy v1 code in v5.
  • The container component (core:container) now allows for exposing ports of any child component via its ports property (see IDE improvements below too). This is a map of IDs to relative port addresses. All specific input / output components (eg. audio:container:in) are now deprecated.
  • Known issue - removing a mapped port will disconnect all connections to the port, including those inside the container (the API is missing the ability to find only outside connections at present).
  • Known issue - deleting a container will sometimes leave child components connected. Always delete connections first. Workaround is to save and reload.
  • Added tell(ControlAddress to, ... msg) and tellIn(double seconds, ControlAddress to, msg) for sending messages to other components, and self() and self(String controlID) for getting own address. core:routing:send is now a re-codeable component.
  • Added @Config.Preferred annotation, mirroring Java's BeanInfo terminology for properties that are particularly important to display to "humans". See Graph Editor improvements for one usage. Added this annotation to value of core:variable component.
  • Tidy up and simplify core API. All Value types now use of() for wrapping a native Java type, parse for converting from text, etc. Call has shorter and simpler creation methods, and uses List for arguments. Many other methods are replaced, with older versions deprecated for removal in v5.
  • Catch errors rather than just exceptions during code context creation. Ensure that amongst other things, an UnsatisfiedLinkError won't take down the component factory service.
  • Functions in the code API that map through to Processing's PApplet have been deprecated. As part of the modularity effort for v5, only video modules will be able to require the Processing module. These can be accessed directly on the PApplet instance (and in v5 by static importing those functions) when it is known Processing is available.
  • Provided new Info builder class for creating ComponentInfo - currently of minimal end-user use until code components allow for info to be customized.
  • Video:
  • video:code:p3d - added mappings for all supported Processing hint() values.
  • Deprecated video:gl:send and video:gl:receive - built-in support for Syphon and Spout. In v5 these can be better supported by adding libraries to projects. Prior to that, switch on display of deprecated components in the palette under Options/General/Components.
  • FIX video:code:p3d - now correctly resets hints and sphere detail on code change, which is not handled by the default settings in Processing. Only a problem since v4.3 started reusing the PGraphics3D.
  • PraxisLIVE IDE:
  • Core:
  • New table based property editors for array and map based properties. TAB will add new rows automatically, DELETE will remove a row. Copy & paste is supported.
  • Updated base IDE to Apache NetBeans 11.1.
  • Graph editor:
  • Added support for showing properties on graph nodes next to related port. Default shows only "preferred" (see above) properties, but options (scene popup) provided to show/hide all. Double-click the value to edit directly. Showing all properties is good for debugging, but adds a little overhead due to syncing and rendering required.
  • Inside a container, a new popup menu option on ports allows adding the port to the container with an ID of choice. To remove or rename a mapping, use the map editor on the ports property.
  • ESC can now be used to go up from a container.
  • Code editor:
  • Experimental inline hints from NetBeans 11.1 to show parameter names in method calls. Still some quirks and off by default - enable in the View menu.

New in Praxis LIVE 4.3.0 (May 24, 2019)

  • PraxisCORE runtime:
  • Core:
  • Added support for running on and (optionally) coding with Java 11 and above.
  • Video:
  • Provided .smooth property in video root to allow Processing's smoothing to be switched off for performance improvements or select needs (eg. fixed pixel rendering).
  • video:code:p3d now keeps existing underlying PGraphics on code changes for performance (small possibility of rendering regressions)
  • Added support for point and line shaders.
  • Added find() to PShader and PShape so that underlying Processing types can be extracted. eg. shader.find(processing.opengl.PShader.class)
  • PraxisLIVE IDE:
  • Core:
  • Updated underlying IDE platform to Apache NetBeans 11.0, which also brings support for running on Java 11+.
  • Added support for building projects using Java 11+. Right-click on a project, select Properties and set the Java version. Can only be done before the project is built (restart the hub, set and build again).
  • Added Browse in System action on folders in projects and in File Manager to open folders in system file browser for easier media management, etc.
  • Graph editor:
  • Open code editor rather than property editor by holding down SHIFT while double-clicking / pressing ENTER on a component.
  • Duplicate selected component(s) using menu item or CTRL-D/CMD-D. Equivalent to copy & paste but without having to wait for sync to complete manually.
  • FIX exporting component(s) without adding to palette now works correctly.
  • FIX keyboard actions select lists forcing output text to lower case.
  • Code editor:
  • Added import groups to editor so that (most) automatic imports sort after default imports and don't fail due to guarded section.
  • Auto-formatting the code (CTRL-SHIFT-F) no longer forces newlines between annotations.
  • Build infrastructure:
  • Updated build system to download NetBeans platform so that both PraxisLIVE and PraxisCORE can be built easily outside of the NetBeans IDE.
  • Added support for building the Windows and macOS distributions into the build script.

New in Praxis LIVE 4.2.0 (Apr 5, 2019)

  • PraxisLIVE v4.2.0 provides updates to the Processing, GStreamer binding, Tinkerforge and JNA libraries, as well as providing a few additional features.

New in Praxis LIVE 4.1.1 (Oct 22, 2018)

  • Fixes:
  • PraxisLIVE IDE:
  • IDE:
  • Fix import action not showing on resources folder in projects.
  • PraxisCORE runtime:
  • Core:
  • Fix issues with clear and accumulate in new Data Pipe API - not behaving correctly with clear functions returning new objects, or accumulate where the source packet was in the list being accumulated (graph recursion).

New in Praxis LIVE 4.0.0 (May 20, 2018)

  • PRAXIS LIVE IDE:
  • Core:
  • New start page with modular sections.
  • Tweaked UI (this is the first major Praxis LIVE version not to change look and feel!) with added space between elements. The default font size has been increased (14pt) - this can be changed by running Praxis LIVE with eg. --fontsize 12, either from the command line or by editing the configuration file.
  • Semantic version checking. Update checking is now based on semantic versioning. Version is written into project files and custom components, and a warning issued if running on a lower version. CLI usage outputs version - full version validation for distributed hubs coming.
  • New root wizard changed with fewer options and different templates for audio (output added automatically) and video (OpenGL, always on top, output added). User defined templates to follow.
  • Fake properties for input port controls (see CORE change) - easily send eg. note to synth from property tab / component editor.
  • Default user directory updated to .praxislive4 (CORE now has a different default user directory - .praxiscore4)
  • Graph editor:
  • New graph UI with colour-coded types and bezier connections, and responsive to font size.
  • PRAXIS CORE RUNTIME:
  • Core:
  • Praxis CORE is relicensed under the LGPL.
  • Embedded runtime compiler removed - the runtime no longer includes a fork of the Java compiler and relies on the compiler provided by the JDK (a JDK is now a runtime requirement, but will be included in the Windows and Mac bundles)
  • Code templating revised - built-in components are now pre-compiled (easier development and testing; faster project builds) but still re-codeable - source templates are built using an annotation processor.
  • Input ports now also have a control - eg. you can now send messages to an input port from MIDI, OSC, another patch or the IDE directly.
  • New timing API introduced, which will eventually allow hubs to run from alternative clock sources (eg. soundcard).
  • Use of setup() in non-video components has been deprecated in favour of init() - this is for consistency to avoid the confusion with setup() being called later in video components (also see video improvements)
  • The Argument type has been replaced by Value and it or any subtype can now be used for input methods and property fields. Optional may also be used for types that do not have a default empty representation (eg. Optional)
  • Default imports for custom components have been updated to include java.util.stream.* and java.util.function.*, as well as org.praxislive.core.* - some types that were deprecated due to name clashes (eg. @Port) have been removed.
  • All code has been refactored under org.praxislive, and various classes and modules restructured (eg. to separate legacy components and Swing dependencies) - this should only be a breaking change for projects if you have imported internal types into your custom components.
  • FIX - projects without additional libraries created in v3.4+ should run correctly with the command line player / standalone.
  • Audio:
  • New audio:looper component for live sampling.
  • New Looper UGen based on Player with multi-channel record capability.
  • New Phasor UGen - similar to sawtooth LFO but with controllable min / max values.
  • The simple atan-based overdrive UGen has been rewritten not to use GPL code. It might sound a little different.
  • Video:
  • video:composite and video:x-fader are now completely rewritten and re-codeable.
  • New API to add render and alpha queries to video input ports (required for above, but usable elsewhere)
  • GStreamer support completely rewritten. video:player and video:capture are now fully re-codeable. The video player has additional functionality, included an end-of-stream signal and zoom. The capture component now defaults to the automatic video source (confusing for new users).
  • New VideoPlayer and VideoCapture types can be used in video:custom components - see code of above for example usage (making these components copy the Processing Video API and extend PImage was considered but rejected for performance reasons).
  • All video components now also support init() and update() methods. They are called prior to the rendering cycle - you cannot draw anything and input images will not have been updated.
  • Processing and JOGL libraries updated to 3.3.7.
  • GStreamer and JNA libraries updated.
  • FIX default MacOS capture pipeline no longer worked.

New in Praxis LIVE 4.0.0 RC 1 (Apr 20, 2018)

  • PRAXIS LIVE IDE:
  • Core:
  • New start page with modular sections:
  • Tweaked UI (this is the first major Praxis LIVE version not to change look and feel!) with added space between elements. The default font size has been increased (14pt) - this can be changed by running Praxis LIVE with eg. --fontsize 12, either from the command line or by editing the configuration file.
  • Semantic version checking. Update checking is now based on semantic versioning. Version is written into project files and custom components, and a warning issued if running on a lower version. CLI usage outputs version - full version validation for distributed hubs coming.
  • New root wizard changed with fewer options and different templates for audio (output added automatically) and video (OpenGL, always on top, output added). User defined templates to follow.
  • Fake properties for input port controls (see CORE change) - easily send eg. note to synth from property tab / component editor.
  • Default user directory updated to .praxislive4 (CORE now has a different default user directory - .praxiscore4)
  • Graph editor:
  • New graph UI with colour-coded types and bezier connections, and responsive to font size.
  • PRAXIS CORE RUNTIME:
  • Core:
  • Praxis CORE is relicensed under the LGPL.
  • Embedded runtime compiler removed - the runtime no longer includes a fork of the Java compiler and relies on the compiler provided by the JDK (a JDK is now a runtime requirement, but will be included in the Windows and Mac bundles)
  • Code templating revised - built-in components are now pre-compiled (easier development and testing; faster project builds) but still re-codeable - source templates are built using an annotation processor.
  • Input ports now also have a control - eg. you can now send messages to an input port from MIDI, OSC, another patch or the IDE directly.
  • New timing API introduced, which will eventually allow hubs to run from alternative clock sources (eg. soundcard).
  • Use of setup() in non-video components has been deprecated in favour of init() - this is for consistency to avoid the confusion with setup() being called later in video components (also see video improvements)
  • The Argument type has been replaced by Value and it or any subtype can now be used for input methods and property fields. Optional may also be used for types that do not have a default empty representation (eg. Optional)
  • Default imports for custom components have been updated to include java.util.stream.* and java.util.function.*, as well as org.praxislive.core.* - some types that were deprecated due to name clashes (eg. @Port) have been removed.
  • All code has been refactored under org.praxislive, and various classes and modules restructured (eg. to separate legacy components and Swing dependencies) - this should only be a breaking change for projects if you have imported internal types into your custom components.
  • FIX - projects without additional libraries created in v3.4+ should run correctly with the command line player / standalone.
  • Audio:
  • New audio:looper component for live sampling.
  • New Looper UGen based on Player with multi-channel record capability.
  • New Phasor UGen - similar to sawtooth LFO but with controllable min / max values.
  • The simple atan-based overdrive UGen has been rewritten not to use GPL code. It might sound a little different.
  • Video:
  • video:composite and video:x-fader are now completely rewritten and re-codeable.
  • New API to add render and alpha queries to video input ports (required for above, but usable elsewhere)
  • GStreamer support completely rewritten. video:player and video:capture are now fully re-codeable. The video player has additional functionality, included an end-of-stream signal and zoom. The capture component now defaults to the automatic video source (confusing for new users).
  • New VideoPlayer and VideoCapture types can be used in video:custom components - see code of above for example usage (making these components copy the Processing Video API and extend PImage was considered but rejected for performance reasons).
  • All video components now also support init() and update() methods. They are called prior to the rendering cycle - you cannot draw anything and input images will not have been updated.
  • Processing and JOGL libraries updated to 3.3.7.
  • GStreamer and JNA libraries updated.
  • FIX default MacOS capture pipeline no longer worked.

New in Praxis LIVE 3.5.0 (Jan 30, 2018)

  • RUNTIME:
  • Core:
  • Deprecated @Port and replaced with @Config.Port - former will be removed in v4 because of name collision.
  • Improve feedback if Error thrown (rather than Exception) as can happen with the library support added in v3.4
  • Audio:
  • Deprecated Table and replaced with AudioTable - former will be removed in v4 because of name collision.
  • Video:
  • Improved support for @OffScreen PGraphics in video:custom. Added support for scaleWidth and scaleHeight properties (1.0 is default and same as output), as well as persistent to control whether the surface can be released after drawing each frame (default true to keep content).
  • Added support for @OffScreen in video:gl:p2d and video:gl:p3d. Adds ability for multi-pass shader FX amongst other things - some additional components using this to follow. NB. the field types are PGraphics2D and PGraphics3D respectively. There is not currently support for 3D graphics in 2D components, or vice versa - this is planned.
  • Added find() method in video:gl:p2d and video:gl:p3d, as well as related PImage and PGraphics2D/3D to get access to underlying Processing types for use with libraries, etc.
  • IDE:
  • Core:
  • Added an action in the Help menu to open Core JavaDoc in the browser. NB. All codeable components have access to the methods defined in DefaultCodeDelegate.
  • Code editor:
  • Added code templates to ease creation of annotations - type the shorthand then TAB - use ENTER to move through the different values.

New in Praxis LIVE 3.4.0 (Dec 21, 2017)

  • RUNTIME:
  • Core:
  • Added support for using additional Java libraries (JAR files) in projects.
  • Added Ref type for managing references to any object across code changes.
  • Added Optional find(Class type) method for searching component lookups for useful objects (eg. PApplet)
  • Added JavaDoc to core user-code API.
  • Added possibility to extend script commands from other modules, added glob wildcard support to file-list PCL script command, and added ls, pwd, cd and add-libs commands.
  • Fix core:routing:delay and possibly other components broken by switch to Value in previous release.
  • Audio:
  • Fix loading of 32-bit float audio files.
  • Video:
  • Added renderer specific lookup, and merge into video root lookup; added PApplet to lookup when OpenGL renderer in use.
  • Updated JOGL library to version used in Processing 3.3.6 to fix Raspbian rendering issues.
  • Better error protection in case of Exceptions thrown by renderer - video window should no longer be left open and the video patch should still be controllable.
  • TinkerForge:
  • Updated TinkerForge library too v2.1.16 for new bricklet support.
  • IDE:
  • Core:
  • Added simple UI for managing third-party libraries in project properties.
  • Code editor:
  • Added Core JavaDoc to build process. Documentation now shows up in code completion, and Show JavaDoc action (right-click on type/method) now functions.

New in Praxis LIVE 3.3.0 (Oct 14, 2017)

  • RUNTIME:
  • Core:
  • enum fields are now supported directly as properties.
  • Added whenDone() method to Property.Animator. Takes account of any overrun of time. Use insetup() like x.animator().whenDone(p -> p.to(random(0,1)).in(5).easeInOut());
  • Added transmit method - acts like a temporary output port and connection. Use sparingly, but useful for live coding. eg. transmit("synth1", "attack", 0.1);
  • Added millis() method.
  • Value is now a general replacement for Argument (using Argument directly is now deprecated).
  • Enhanced d(), i(), etc. methods to extract double, int, etc. from Value and String. Also added equivalent boolean b() and PArray array() methods.
  • Enhanced PArray.get(index) to wrap index value rather than throw exception. Added append, splice, subset and concat support for PArray.
  • New Input field type with Linkable API support - eg. in setup() do things like
  • in.valuesAs(Value::toString).filter(s -> s.length() > 4).map(String::toUppercase).link(out::send);
  • Added PBytes methods for serializing and deserializing objects.
  • New DataObject interface (currently implemented by PVector) for efficient read/write of binary data, with suitable supporting methods (streamOf() / forEachIn()) in PBytes.
  • Audio:
  • Updated JavaSound output to clamp values - saturate rather than hard distortion in case of clipping.
  • Video:
  • Support for OBJ file loading in PShape fields.
  • Added method to create a mutable clone of a PShape - eg. to switch off styling of a shape loaded from a file, etc.
  • Access to mouse and keyboard fields in P2D and P3D. Event methods are not yet supported (not easy!), but full support for event processing is coming in a later release.
  • Option to show cursor added to video:output, rather useful for the above (currently must restart video window - possible Windows issue)
  • Added support for colorMode() in P2D / P3D to allow for HSB colours.
  • Added support for hint() in P3D - currently only supports disabling depth testing.
  • IDE:
  • Core:
  • Added actions (triggers) as buttons in the property table so they now show in the property tab (input controls to follow).
  • Code editor:
  • The property tab now shows properties of the underlying component when editing code.
  • Added new flash-on-save support - quick flash of colour behind all changed lines when saving. Switch off in View menu.
  • Switched to NetBeans multiview editor - enables support for dividing the code editor in two.

New in Praxis LIVE 3.1.0 (May 1, 2017)

  • RUNTIME:
  • Video:
  • Added support for OpenGLES2 for accelerated rendering on the Raspberry Pi, etc.
  • Added OpenGL profiles. It is now possible to select a specific OpenGL profile when selecting the OpenGL renderer. Supported profiles areGL2, GL3, GL4 and GLES2. The default is GL3 on desktop with automatic fallback to GLES2.
  • Added support for texture sharing via Syphon (OSX) and Spout (Windows) using the new video:gl:send and video:gl:receive components. Syphon support currently requires selection of the legacy GL2 profile above.
  • Added support for PFont resource properties, fixed text rendering alpha channel issues in video:gl:p2d/p3d, and added TextRender SurfaceOp.
  • Added support for PShape SVG loading and createShape() for caching geometry.
  • Updated GStreamer-Java bindings fixing loop issue on Windows.
  • Fixed video:player ignoring no-loop setting.
  • Updated Processing library to v3.2.3
  • IDE:
  • Graph editor:
  • Open containers on double-click.

New in Praxis LIVE 3.0.0 (Oct 28, 2016)

  • Further graph editor improvements - more keyboard control, better zoom control.
  • GUI editor improvements
  • JACK MIDI support #2
  • MIDI / OSC improvements - more mapping components, raw MIDI data, learn function (support skew, automatic binding?)
  • Papercuts #37 (remaining)
  • IMPORTANT - GStreamer is no longer included for OSX and Windows and must be installed separately if you want to play videos or use video capture.

New in Praxis LIVE 3.0.0 RC 1 (Oct 8, 2016)

  • Fix up GUI appearance, support skew.
  • Add proper export of custom components.
  • More Java 8 style functional support for audio coding.
  • Add Java 8 Stream support to built-in types.
  • Support Serializable types and Lists of Serializable types using PBytes.
  • MIDI / OSC improvements - status (last-message).
  • Papercuts #37 (partial).

New in Praxis LIVE 3.0.0 Alpha 2 (Sep 17, 2016)

  • Switch to Darcula look-and-feel - OSX menu bar support.
  • Remove legacy GStreamer 0.10 support #35
  • Allow distributed hubs to provide services - compiler, logging, etc. in different process.
  • Add http server so resources can be loaded transparently across distributed hubs.
  • Add skew to numeric control info - better mapping of slider movement to audio gain, frequency, etc.
  • Deprecate old audio components and replace with (stereo) code-based equivalents.
  • Add data root type - graphs for asynchronous tasks.

New in Praxis LIVE 3.0.0 Alpha 1 (Aug 3, 2016)

  • A pre-release of Praxis LIVE v3 for testing purposes
  • There are no installers for pre-releases. Unzip the archive to a suitable location, then run praxis_live (Linux / OS X), praxis_live.exe (Windows x86) or praxis_live64.exe (Windows x64) from inside the bin directory.
  • Praxis LIVE v3 requires Java 8, either Oracle's distribution or OpenJDK.
  • Update infrastructure and compiler to Java 8 #20
  • Update NetBeans platform to v8.1 #23
  • Add PBytes argument type for arbitrary binary data (eg. bytecode)
  • Split compiler service out into separate service from code context factory (part of allowing compiler to run in different process / on remote machine)
  • OpenGL blit op improvements for identity blending (src & dst same size with no offset) - all blend modes in video:composite and video:xfader now in OpenGL.
  • Graph editor improvements - mouse wheel scrolling, snap alignment, keyboard focus cycling
  • FIX video:gl:p3d adding alpha to opaque surfaces.
  • Deprecate old core:container:property component - part of #11

New in Praxis LIVE 2.3.3 (Jul 8, 2016)

  • Fix crash on some (Nvidia) graphics cards when recoding video:gl:p3d components (praxis-live/support#36)

New in Praxis LIVE 2.3.2 (May 13, 2016)

  • fix issue with new video:gl:p2d component leaking matrix transforms affecting downstream components.
  • fix issue with new video:gl:p2d component not remembering style settings from setup() and between calls to draw()
  • fix issue with straight lines not rendering in video:custom component when using OpenGL rendering.
  • add texture matrix and offset uniforms when setting a PImage uniform in custom shaders (technically a new feature!)
  • fix commenting not working in GLSL editor.

New in Praxis LIVE 2.3.1 (Mar 17, 2016)

  • Fixes issue editing projects with containers in them - praxis-live/support#26
  • This is a bug fix release of v2.3 - read the main v2.3.0 release notes for major changes.

New in Praxis LIVE 2.3.0 (Mar 17, 2016)

  • New video:gl:p2d component wrapping Processing's 2D OpenGL graphics. Provides better performance (doesn't require an image copy) and more accurate rendering where 3D capability is not required.
  • Updated shader support allows custom shaders to be used when rendering shapes as well as images.
  • New ability to add comments and custom colouring in the graph editor (praxis-live/support#12 and praxis-live/support#16)
  • Improved reporting of exceptions thrown in user code (praxis-live/support#13)
  • Revised start page and update checking mechanism. Also, all external links to docs and issues are managed through praxislive.org domain (praxis-live/support#21)
  • video:player now supports playback rate and audio output, but currently only when using GStreamer 1.x (non-default option in Tools | Options which requires installation of GStreamer 1.x library). Using JACK it is possible to route audio from a video through an audio processing pipeline.
  • FIX : custom shaders are now pre-processed correctly like internal Processing shaders to match the required GLSL version. Should fix issue with errors on OSX (praxis-live/support#15)
  • FIX : the main project file is now updated whenever a change is made, rather than at application shutdown (praxis-live/support#19)
  • FIX : containers now register correctly as deleted (praxis-live/support#18)
  • FIX : ShapeRender (finally) fixed for some blend modes when software rendering (praxis-live/support#1)
  • FIX : gst1-java-core library updated to later build with fix for loading GStreamer 1.x on OSX

New in Praxis LIVE 2.2.0 (Oct 28, 2015)

  • OpenGL video pipeline updated to Processing v3.0.1 / JOGL v2.3.2. While providing major performance and stability improvements, this is a major change and there is the possibility for some regressions. Please update carefully and report any issues.
  • Optional support for GStreamer 1.x. This can be set under Tools / Options / Video / GStreamer (requires restart). Unlike GStreamer 0.10 support, this requires a system installed version of the GStreamer library on all platforms. Windows and OSX users who want to experiment with this feature can download GStreamer from http://gstreamer.freedesktop.org/download/
  • New core:tracker component, and simple table-based tracker editor (use popup menu and Edit patterns to access). More advanced editing features to follow.
  • New routing components - core:routing:every for allowing through every n-th message, and core:routing:order to prioritise dispatching of messages.
  • New audio:clock component for more stable timing in BPM (quantized to internal processing buffer size).
  • Internal (and outdated) help removed and replaced with link through to online manual at http://praxis-live.readthedocs.org
  • TinkerForge bindings updated to v2.1.5.
  • Added ready and error ports to video:capture and video:player. Can be connected to play or pause to auto-start playback when new file or pipeline loaded.
  • Many minor bug fixes (see commit log).

New in Praxis LIVE 2.0 Build 150414 (Apr 15, 2015)

  • ISSUES FIXED:
  • Video:
  • NullPointerException when restarting OpenGL video pipeline with alpha channel. Incorrect logic in video:composite meant that the surface from the old GL context was not properly replaced when using force-alpha.
  • Visual editor:
  • Editor color theme incorrect on Java 8. The text editor color theme (black background) was being ignored, probably due to some incorrect configuration overrides, though exact reason this was working correctly in Java 7 but not Java 8 is currently unknown. Please reopen the issue if this is still happening.

New in Praxis LIVE 2.0 Build 141101 Alpha (Jan 15, 2015)

  • New features:
  • In addition to the new features mentioned in the previous release notes, this release brings the following major new features
  • New root hub implementation with support for distributed hubs. Run a Praxis LIVE project across multiple local slaves (eg. reduce GC pauses, audio latency) or across a network. Settings in Options / Core / Network. More information in this blog post.
  • Updated JAudioLibs audio servers and JACK support to v1.1.1.
  • Improved performance.
  • Improved device selection support in general settings and per audio root.
  • Sample rate and internal block size (default 64 samples) now specified for each audio root rather than globally (this may cause some projects to sound incorrect until the settings are changed).

New in Praxis LIVE 1.0 Build 131206 (Jan 15, 2015)

  • This is a minor bug-fix release, though with some additions to the TinkerForge bindings. Some major features that are currently in development have been left out of this release in favour of stability.
  • NEW FEATURES:
  • TinkerForge:
  • New component bindings. Bindings have been added for Analog In, Analog Out, Barometer, Dual Relay, LCD 16x2 (in test), Temperature and Temperature IR bricklets. Thanks to the TinkerForge team for their support in developing these new bindings.
  • Library update. The TinkerForge library has been updated to version 2.0.12.
  • Video:
  • OpenGL library update. The LWJGL library has been updated to version 2.9.1. This brings a whole new OSX backend.
  • ISSUES FIXED:
  • Core:
  • Incorrect property behaviour. Properties were incorrectly ignoring subsequent settings received at the same timecode, which might happen in a complicated cascade of messages. There is a minor chance that this change could cause a complicated patch to behave differently.
  • TinkerForge:
  • Not working over WiFi, etc. The TinkerForge root was not behaving correctly in cases where an enumeration was automatically triggered by connecting to a brick. This meant that connection over WiFi, and probably anything other than USB, was breaking in Praxis LIVE. This behaviour has now been corrected, though you may sometimes still see exceptions reported.
  • Video:
  • BufferedImageSurface breaking image save. The image save component (currently still in test status), was failing due to the fact that the BufferedImageSurface was not compatible with other surface types now used in the software and OpenGL pipelines. This is now fixed.
  • Praxis LIVE:
  • Slider property editors not working on OSX, and possibly elsewhere. On OSX, dragging on numerical property was focusing the text field rather than acting as a slider. This has now been fixed by changing how and when the component checks for the event that is triggering it.