Softpedia >Windows >Multimedia >Audio >Other AUDIO Tools >Praxis LIVE >  Changelog

Praxis LIVE Changelog

What's new in Praxis LIVE 5.7.0

Aug 4, 2023
  • Latest release of PraxisLIVE ... release notes to follow.

New in Praxis LIVE 5.6.0 (Jun 5, 2023)

  • This release provides support for recodeable root components, and a range of bug fixes. More info to follow ...

New in Praxis LIVE 5.3.0 (Sep 27, 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<String> 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. eg.
  • @Proxy Runnable foo = this::doFoo;
  • @Proxy DoubleUnaryOperator bar = x -> sin(x*x);
  • 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.
  • @Persist int counter;
  • @Persist(autoReset = false) Future<String> result;
  • 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 (Apr 27, 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.
  • Working remotely with Raspberry Pi, etc.:
  • As well as running the full PraxisLIVE IDE on the Pi, it's possible to just run the PraxisCORE runtime and connect to it from another computer.
  • The PraxisCORE runtime can be extracted from the praxiscore directory inside the IDE
  • Maven Package URLs:
  • External libraries are referenced using a Package URL or PURL. This is a concise format that also works with various aspects of the existing library support that expect URLs.
  • To add a library URL to a project, access the project properties (right-click on project node) and use the libraries section. Click Add to add a library URL. Libraries may not be removed from an active project (eg. built or running).

New in Praxis LIVE 5.0.0 (Sep 22, 2020)

  • This is the first full release of PraxisCORE and PraxisLIVE v5.x. Windows and macOS bundles, as well as a zip bundle, are below. Linux users may try the new AppImage based packaging, which also includes an embedded JDK from AdoptOpenJDK, or use the zip bundle that uses the system installed JDK. To use the AppImage simply download, make it executable and run it.
  • 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 5.0.0 Beta 2 (Aug 15, 2020)

  • Added basic check for active projects on IDE exit.
  • Fixed OpenGL window not closing on macOS (added workaround for bug in underlying GLFW).
  • Fixed Windows child processes not exiting.
  • Fixed occasional ClassNotFoundException due to clash between how PraxisCORE is bundled and NetBeans manifest caching.
  • Fixed table grid not showing in various editors, due to different defaults in FlatLaf.
  • Fixed message caused by invalid setting in GStreamer capture string.

New in Praxis LIVE 5.0.0 Beta 1 (Jul 31, 2020)

  • This is the first beta release of PraxisCORE and PraxisLIVE v5. Windows and macOS bundles, as well as a zip bundle, are below. Linux users should use the zip bundle for now - alternative packaging for Linux to replace the previous .deb install is underway.
  • 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 - a Java 11 JDK from AdoptOpenJDK is included in the Windows and macOS packages.
  • PraxisLIVE nows 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 3, 2019)

  • Changes:
  • 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<Value> 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. To remove or rename a mapping, use the map editor on the ports property.
  • Inside a container, a new popup menu option on ports allows adding the port to the container with an ID of choice.
  • 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.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 19, 2018)

  • Fixes:
  • PraxisLIVE 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 14, 2018)

  • A major focus for v4 is relicensing the Praxis CORE runtime as LGPL. There will be better support for building standalone projects from the IDE. And there will also be a focus on the use of Praxis CORE as a general purpose Java runtime / library in other fields that can benefit from distributed real-time coding / hot code reloading.
  • Of course, Praxis LIVE's primary use for interactive / live creative coding hasn't been neglected in this release! There are a range of new features, a revised patching UI and a big push to remove legacy code and add features to allow remaining legacy components to be re-codeable.
  • In development of this release, the project has been restructured and much legacy code removed. Projects from v3 that were not making use of deprecated features or components should still work, although you may see warnings / errors on first build. File an issue if you have difficulties.
  • Praxis LIVE IDE:
  • Core:
  • New start page with modular sections.
  • Option to download and install examples as project templates, with update check.
  • Option to download and install custom components into the palette, with update check.
  • Check for GStreamer libraries and download link.
  • 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<ControlAddress>)
  • 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 25, 2018)

  • CHANGES:
  • 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.
  • Updated Syphon libraries to support use with standard OpenGL Core Profile (no longer required to set renderer to legacy OpenGL 2)
  • FIX major issue introduced in 3.4 where code couldn't be edited / new components couldn't be added if a video root had been restarted.
  • 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. For specific additional functionality
  • Add/remove multiple libraries at a time.
  • 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 22, 2017)

  • Changes:
  • Runtime:
  • Core:
  • Added support for using additional Java libraries (JAR files) in projects.
  • Added Ref<T> type for managing references to any object across code changes.
  • Added Optional<T> find(Class<T> 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.
  • Additional libraries:
  • To add a *.jar file to a project, open the project properties window (right-click on main project folder). Select files to import - files will be copied into the hidden config folder, and available in the classpath. Libraries can only be removed if the project isn't active.
  • Ref / find()
  • Ref<T> is a safe way to manage references across code changes. The reference must be initialized before use. Handlers can be added for onReset() and onDispose() - the former will be called every code change, the latter when the root is stopped or the reference deleted. If the referred object is AutoCloseable it will be closed automatically on disposal.

New in Praxis LIVE 3.3.0 (Oct 18, 2017)

  • Changes:
  • 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.2.0 (Aug 21, 2017)

  • RUNTIME:
  • Core:
  • new Linkable API - lightweight reactive-streams like API; support added in Property and Trigger (see below).
  • component lifecycle improvements - setup() should always be called before other user code (except in video components - to follow)
  • Video:
  • Updated Processing library to v3.3.5 - various OpenGL improvements, particularly on the Pi.
  • Fix aspect ratio when using rotated output and OpenGL renderer.
  • Stop using Processing icon for OpenGL window.
  • TinkerForge:
  • Update TinkerForge library to v2.1.14
  • IDE:
  • Core:
  • Update NetBeans Platform to v8.2
  • Graph editor:
  • Keyboard actions for adding components, selecting components, calling properties/actions, and making/breaking connections (see below)
  • Experimental auto-layout action on ALT-SHIFT-F
  • Use arrow keys to move selected components.
  • Changed TAB behaviour to select and focus when less than two components selected, otherwise cycle focus between selected components.
  • Make sure component positions are always synced before saving.
  • LINKABLES:
  • The Linkable API is a different way of responding to actions (triggers) and property changes, based on a simplified form of reactive streams. There is a Linkable<T>, plus primitive versions Linkable.Int and Linkable.Double. All currently support filter() and map().
  • GRAPH ACTIONS:
  • The graph keyboard actions support adding components, selecting components, calling properties/actions, and making/breaking connections. Actions appear in a bar at the bottom of the graph window, and are triggered by keys based on the syntax of the Praxis Command Language used in the terminal and in project files. Fields have an auto-complete list (trigger by typing or down-arrow), and most support glob syntax for multiple selection. TAB between fields, use RETURN to action, or ESCAPE to close the action.
  • @ - Add a new component. Suggest field of components from palette. Components currently appear in the same location - use arrow keys or new layout action to move.
  • / - Select component(s). Single text field with suggestions and glob support (eg. use * to select all).
  • . - Call action / change property. Selected component will be pre-filled but can be changed. Control field lists available controls. For properties, value field will show current value. Component field supports glob syntax, so same control on multiple components can be changed in one action.
  • ~ - Connect component ports. Fields are source component, source component output, destination component, and destination component input. All fields support glob syntax for making multiple connections in one action. Multiple ports are cycled - eg. out* and in* will connect out-1 to in-1 and out-2 to in-2.
  • ! - Disconnect component ports. Fields as above. Destination is pre-filled with *.

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 2.3.3 Build 160707 (Jul 8, 2016)

  • This is a bug fix release of v2.3 - read the main v2.3.0 release notes for major changes.
  • Fix crash on some (Nvidia) graphics cards when recoding video:gl:p3d components (praxis-live/support#36)

New in Praxis LIVE 2.3.2 Build 160317 (May 14, 2016)

  • This is a bug fix release of v2.3 - read the main v2.3.0 release notes for major changes:
  • 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 Build 160317 (Mar 18, 2016)

  • Fixes issue editing projects with containers in them

New in Praxis LIVE 2.3 Build 160317 (Mar 18, 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 : 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)

New in Praxis LIVE 2.2 Build 151028 (Nov 14, 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 colour theme incorrect on Java 8. The text editor colour 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 150313 (Mar 25, 2015)

  • MAJOR NEW FEATURES:
  • Core:
  • Fork All. New, improved live-code API and migration of built-in components, allowing for components to be evolved on-the-fly and making it easier to develop and share custom components.
  • Distributed Hubs. Run a project across multiple computers, or multiple processes on one machine eg. for better framerates or lower-latency audio.
  • Video:
  • New OpenGL video pipeline. The OpenGL pipeline is now based on Processing, both simplifying development and making new features easier to provide.
  • Direct access to Processing. The new video:gl:p3d component provides custom-code support with almost complete access to Processing's 2D and 3D functions.
  • Better video playback and capture control. Video capture now allows use of any GStreamer pipeline instead of the default configuration, and improved support for requesting specific dimensions and framerate from a camera, etc. Both capture and playback allow for control of how video is resized to fit the output.
  • Better output window control. Controls on video:output allow for controlling the output window title & screen, whether it's undecorated or always-on-top, and whether it should be full screen. (NB. full screen is no longer a property of the video root)
  • TinkerForge:
  • Fork All / custom code support. The TinkerForge bindings now support custom coding, and the code of all the built-in bindings can be edited. So, while there isn't yet support for all components, you can simply write your own!
  • Audio:
  • Updated JAudioLibs audio servers and JACK support. Improved performance and device selection.
  • Per-root sample rate and block size. Sample rate and internal block size are now specified in the properties of each audio root rather than globally. Some existing projects may sound incorrect until these settings are changed.
  • Distributed Hubs. As mentioned above, one of the primary reasons for running a project across multiple processes is improved audio latency. The default configuration when distributed hubs are used is to run audio in a separate Java VM.
  • Visual Editor:
  • NetBeans-based code editing. Code editing now uses the editor from the NetBeans platform, with code completion and error highlighting support. Code properties are no longer accessible from the Properties window, but from the popup menu on each component. This will open a separate editor window. Save the code to update the component. NB. Saving the code will update the component, but the code will not be saved to disk until the project is saved.
  • Import custom components to palette. Palette support has been rewritten to be file-based, meaning that it's now possible to import custom component / subgraph (.pxg) files to the palette. To import, use the popup menu on a palette category and select Import ...
  • Improved error reporting. A new logging API has been added for components to report errors to the screen.
  • Much, much more:
  • Many other minor changes and bug fixes have been made during the development of Praxis LIVE v2. If you really want, you can also check the commit logs for the praxis and praxis-live repositories on GitHub.

New in Praxis LIVE Build 131206 (Dec 7, 2013)

  • The installer now includes the GStreamer plugin to directly support video playback and capture.

New in Praxis LIVE Build 130831 (Sep 4, 2013)

  • New features:
  • Core:
  • Root performance improvement. A major architectural revision of the base class for all provided root components allows for the message queue to be driven externally, such as in-between video frames. This fixes issue 33, and should provide better responsiveness and timing accuracy. Additionally related changes have allowed for more responsiveness to external control in the MIDI, OSC and TinkerForge pipelines. This is a major change - no regressions have been noticed yet, but please report any issues.
  • User Containers / Properties. Container components moved out of test status. Properties (core:container:property) enhanced with ability to specify numeric types and ranges (eg. allow slider control in container UI).
  • Enhanced Boolean Number conversion. Boolean (true / false) values now convert automatically to numbers (1 / 0) where required, and numbers are automatically convert to booleans (greater than 0.5 is considered true). Useful for certain control inputs and outputs, particularly in the TinkerForge bindings.
  • Audio:
  • Stereo sample player moved out of test status.
  • Video:
  • Specify output screen. It is now possible to specify the output screen device. Currently this is done numerically - use the drop-down selection on the video:output component. Full screen status is still changed in the main video root configuration - this will be moved to the video:output component.
  • OpenGL output scaling. The OpenGL pipeline now supports the ability to scale output using the width & height parameters on the video:output component. Rotation is still not supported. Remember that this is not the dimension of frames being processed, which is set in the video root settings - this just scales the output.
  • Vertex shader and screen clearing in GL filter. The video:opengl:filter component now supports vertex shaders as well as fragment shaders. A new parameter to clear the screen (on by default) has been added in case of not rendering across the entire frame. If using a shader that renders across the entire screen, you can switch the clearing off for better performance.
  • OSX GStreamer libs bundled. The GStreamer libs for OSX are now bundled in the full Zip download. This has not been as heavily tested as the Windows bundling - please report any issues.
  • OSC:
  • OSC support moved out of test status.
  • TinkerForge:
  • New component bindings. Bindings have been added for the IO16, Joystick and Linear Poti bricklets; and the Servo brick.
  • Auto UID support. For simple patches and to allow sharing of examples, the UID parameter now supports an setting. This will lock the first available device of the correct type, so should work for many cases. Manually specifying the UID is still recommended for most cases though.
  • Improved LCD20x4 support. The LCD20x4 binding has been improved with better character encoding, support for buttons and change in the way the display is updated (was causing flashing).
  • Praxis LIVE:
  • Start Page. A new start page has been added which provides links to the new Praxis LIVE website, and checks with the website for program updates. More features will be added to this start page over time. It can be switched off in the options window.
  • New icons and splash screen. The icons and splash screen have been redesigned to reflect the new design on the website. The icon is actually a screenshot of a GLSL shader running in Praxis LIVE itself.
  • Fixes for dynamic components. Some fixes have been made to the way dynamic component changes are reflected in the editor.
  • Issues fixed:
  • Architecture changes should fix issues around paste & import taking a long time in an active root - issue 33.

New in Praxis LIVE Build 130508 (May 14, 2013)

  • New features:
  • Core:
  • User Containers. Support for creating container components (core:container) that can contain other components, with properties (core:container:property) and ports (audio:container:*, etc.) showing on the parent. Currently marked as test status - use Tools/Options to enable showing of test components.
  • Code Param animation modes. Animatable parameters in custom code components now support a variety of interpolators, based on CSS options - linear (default), ease, easeIn, easeOut, easeInOut. Can be used by doing eg. p(1).to(0.5).in(5).easeInOut();
  • Component MetaData. Component factories can now provide additional information about components. Biggest visible change for now is that test components will now have the ID they're intended to have on release. Test components show in italic in the palette. Also support for marking component deprecation and replacements - will make it easier to provide new components into the future.
  • TextEditor GLSL support. The text editor now has basic GLSL syntax support.
  • Audio:
  • Stereo sample player at audio:sampling:player. Marked as test, though due to some plans to refactor this further for the next release - should be stable. Use Tools/Options to get it to show in the palette. Requested by Amélie Polachowska.
  • JAudioLibs - separate repository. Much of the audio code in Praxis can be used by any Java application. Though it has been released separately for some time, development has now been moved to encourage reuse - https://github.com/jaudiolibs/
  • Video:
  • Transformed blitting. Support for drawing transformed, particularly rotated, video. Only accessible through custom code components at the moment - new draw() functions rotate(), translate(), scale(), resetMatrix(). Should work identically to their Processing counterparts (2D only).
  • Renderer setting per root. It's now possible to override the renderer setting on a per-root basis. Primary usage is to allow for a low-resolution, low-framerate software pipeline to do motion detection / tracking to control a high-resolution OpenGL pipeline.
  • (OpenGL) pipeline improvements. Texture caching and modification tracking ensure non-GL data is only uploaded when necessary. Native pixel data implementation allows direct transfer of GStreamer video data to OpenGL without entering Java memory. SurfaceOps now reusable (mutable). Combined these provide a massive performance boost for working with video sources and still images.
  • OSC:
  • New support for OSC input. Start of OSC support in Praxis through the NetUtil library (http://www.sciss.de/netutil/). Currently only input, UDP and running as a server is supported. OSC input components require a control address - as these are OSC compatible, the control address is the default OSC identifier, but can be overridden. Default port for the server is 1234 but can be changed. The root:osc component will not show in the template menu by default - use New / Other...` Requested by Ryan Webber.
  • TinkerForge:
  • Update to API v2. The TinkerForge (http://www.tinkerforge.com/) bindings have been updated to version 2 of the API, which work a lot better in the context of how Praxis uses them. Still only support for the starter kit components - more to come.
  • Praxis LIVE:
  • Copy & paste. It's now possible to copy & paste components (or multiple components and connections). A dialog provides intelligent (but overridable) renaming where necessary. It is achieved by saving a section of the graph as text to the clipboard (of which more in a moment). Currently only enabled in the graph editor.
  • SubGraph (.pxg) files and import. SubGraph files are designed to fulfil the need for code reuse, macros, custom components, etc. Use the File Browser to find the file and drag into the editor (graph editor only for now). Uses the same infrastructure as copy & paste. Longer term, support will be provided for importing these to the palette. There is no export at the moment - however, you can easily create a SubGraph file by selecting the relevant components and copy & pasting them into a text editor, making sure to save the file with a .pxg extension.
  • Graph editor container support. The graph editor now supports user containers. Drag a core:container component onto the graph. You can then select Open in the component's popup menu to add components to it. Use the up arrow in the toolbar to return to the parent level. Note that core:container:property controls and container ports show up on the parent.
  • Other graph editor UI improvements. Rounded corners. Move all selected components together. Ports disappear when zooming out (CTRL-mousewheel) to speed up rendering and allow easier selection / dragging. Did I mention rounded corners! :-)
  • OSC editor. Editor implementation for OSC bindings based on MIDI editor.
  • Issues fixed:
  • New template management based around component metadata should stop an exception that was being reported with the TinkerForge root.
  • Switched default file encoding to UTF-8 on all platforms. Should fix problems with Russian (and other!) characters in filenames.

New in Praxis LIVE Build 121231 (Jan 3, 2013)

  • New features:
  • Core:
  • Dynamic Components. Support for components to change configuration (controls / ports) at runtime. Initially supports the multi-channel audio improvements (below), this will also allow for supporting sub-component graphs amongst a range of other future features.
  • New Text Editor API. Improved syntax highlighting text editor components (based on RSyntaxTextArea). This is currently only used within Praxis LIVE, but a component for control panels will follow.
  • Audio:
  • Multi-channel audio support. It is now possible to use up to 16 channels for input and output (system dependent). Use the .channels control on the audio:input or audio:output. NB. This value is only read when the audio first starts, so additional channels will be silent until you restart audio. Also note the issue below.
  • Video:
  • Re-factored and improved video pipeline. The video pipeline has had some major work to improve performance and stability, particularly of the OpenGL renderer (which is now marked "beta" rather than "Highly Experimental"!). This work also paves the way for further improvements and features in the next release.
  • GStreamer plugin for Windows included. The GStreamer plugin for Windows is now included in the installer for Windows and the full version of the Zip distribution, allowing for video playback and capture without extra installation. Also useful for distributing stand-alone projects.
  • TinkerForge:
  • A start has been made on bindings for TinkerForge components (http://www.tinkerforge.com/) for various forms of physical computing. Currently the components from the starter kit (LCD20x4, Rotary pot, IR distance sensor, Light sensor) are supported. To create a TinkerForge root, go to New / Other... and select Praxis Root File. You can then select the root:tinkerforge type. It's a little hidden away as development is waiting on v2.0 of the TinkerForge protocol to be released.
  • Praxis LIVE:
  • Upgraded to NetBeans Platform 7.2. Bringing improved performance and bug fixes, as well as a few nice new features, including -
  • Document tab groups Have multiple editors open and visible at the same time, great for larger screens. Simply right-click on the tab of an open editor and select the option to open in a new group.
  • Project import / export Import and Export projects directly to from Zip files (in the File menu).
  • Improved Resource and Control Address dialogs. The editors for resources (files) and controls addresses (bindings, send, etc.) have been improved. The Resource editor now includes a file browser of the Resources folder of the project - external files can still be selected using the browse button. The Control Address editor now allows you to browse through a tree of all components and controls to visually select the one you want.
  • Improved Code Editor. The code editor dialog has been improved using the new Text Editor API mentioned above. A new toolbar allows you to send (compile) the code without closing the window, or re-sync to the existing code.
  • Import Resources. A new item in the popup menu for the Resources folder and sub-folders allows you to select files to import into your project.
  • Graph editor improvements. The graph editor now saves the minimized state of components, allowing for more compact graphs to be saved. There have also been a number of tweaks to the appearance of the graph.
  • Linux .deb installer. The default installer for Linux is now a .deb installer which installs Praxis LIVE and the Praxis command line player for system-wide usage. Non-installed usage is still possible using the Zip distribution, but the .deb is the preferred option.
  • Issues fixed:
  • Unity / Gnome issues seem to mostly be fixed by switching to the .deb installer.
  • The new Text Editor API (and removal of JSyntaxPane) removes the Null Pointer Exception issues when closing text files.

New in Praxis LIVE Build 120912 (Sep 14, 2012)

  • New features:
  • Core:
  • Command line player. This release sees the return of the Praxis command line player, now included as part of the Praxis LIVE distribution. Simply call the player with a project directory, project file (.pxp) or script. eg. praxis "examples/01 Hello World"
  • Exit Handlers. It is now possible to exit if a root stops (eg. window is closed). The core now has exit handlers, and each root component now has an exit-on-stop property. If this property is true when a root stops then an exit handler is called. In Praxis LIVE this will cause all other roots to stop; when running from the command line or standalone (coming soon) this will cause the application to exit.
  • Praxis LIVE:
  • Improved Argument property editors. It is now possible to use the file (resource) and file list editors when editing properties of the generic Argument type. Most usefully, this allows you to set core:property or core:variable values to relative files without needing an extra script.
  • Issues fixed:
  • A problem with setup() never being called in the core:code:custom component, and general issues with when setup() was called with video:code:composite components, has been fixed. NB. setup() is now called every time the root is started rather than just when the code is first installed on the component.
  • A rare issue with audio that could lead to an invalid JavaSound mixer being chosen has been fixed.
  • Audio input is now not opened if there is no audio:input component in the graph. While this fixes certain issues, it also means that an audio:input component will not work if added to a running audio graph - you will need to restart the audio root.
  • JACK audio now works on Windows 64 with a 64bit JACK and JVM.

New in Praxis LIVE Build 120711 (Aug 20, 2012)

  • fixes an issue with Java 7 that only affects Windows users