Skip to content

Releases: praxis-live/praxis-live

PraxisLIVE v5.4.0

Compare
Choose a tag to compare

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

@In(1) void in(String value) {
    children().forEach(c -> tell(self().resolve(c).control("value"), value));
}

Further capabilities for coding containers and roots are under development.

PraxisLIVE v5.3.0

Compare
Choose a tag to compare

PraxisLIVE v5.3.0 adds support for creating recodeable proxy interfaces (eg. for passing in as listeners to third-party code), persistent fields, and better support for injecting arbitrary types. The IDE is updated to be based on Apache NetBeans 12.4, and now bundles JDK 16 (with JDK 17 support to follow soon).

Changes

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.

package SHARED;
// imports

public class Types extends Ref.Provider {
    public Types() {
        register(List.class, (Ref<List<?>> r) -> r.init(LinkedList::new).onReset(List::clear));
    }
}
@Inject List<String> arrayList;
@Inject(provider = SHARED.Types.class) List<String> linkedList;

PraxisLIVE v5.2.0

Compare
Choose a tag to compare

PraxisLIVE v5.2.0 adds support for components to share common, rewritable code (within one graph). The IDE adds an
action for embedding the runtime inside a project for standalone running. And there's the usual range of small
tweaks and bug fixes.

Changes

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

import SHARED.Foo;
import static SHARED.Utils.*;

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!

PraxisLIVE v5.1.0

Compare
Choose a tag to compare

PraxisLIVE v5.1.0 adds support for running OpenGL(ES) on Raspberry Pi and other ARM devices, supports adding libraries to projects from the Maven Central repository, and brings a range of smaller improvements and bug fixes.

Changes

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 or downloaded from https://github.com/praxis-live/praxiscore/releases

On the Pi, you must have OpenJDK 11 or above installed. From inside the praxiscore directory run -

./bin/praxis --network all --port 42424

Feel free to use any port number. If launching via ssh, you probably want to use export DISPLAY=:0 first to ensure any windows are created on the Pi display.

In the IDE, open the project properties of the project you wish to run on the Pi (right-click on project node). Select the Hub Configuration section and replace the default text with this, changing <IP ADDRESS> to the address of the Pi, and the port number if required.

  enable-fileserver true
  proxies {
    all {
      host <IP ADDRESS>
      port 42424
      id-pattern *
      type-pattern *
    }
  }

Run the project and it should now run on the Pi. Any required files will be served from the IDE machine where they are not available at the same location (relative to user directory) on the Pi.

NB. this should only be done on a secure local network.

Further info at https://docs.praxislive.org/projects/#hub-configuration

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

A Maven PURL has the following format :

pkg:maven/{group-id}/{artefact-id}@{version}

The PURL for any library can be found in searching at https://search.maven.org eg. the PURL for https://search.maven.org/artifact/org.apache.commons/commons-lang3/3.11/jar is pkg:maven/org.apache.commons/commons-lang3@3.11

Only pkg:maven PURLs are supported at present, and query parameters are not yet supported.

The Maven dependency resolution is currently based on Apache Ivy. Cached dependencies are stored in the default (~/.ivy2/cache) location.

PraxisLIVE v5.0.0

Compare
Choose a tag to compare

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

Please report any problems at https://github.com/praxis-live/support/issues

PraxisLIVE v5.0.0-beta-2

Compare
Choose a tag to compare
Pre-release

This is the second beta release of PraxisCORE and PraxisLIVE v5. 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. Simply make the AppImage 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 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).

Known Issues

  • Capture does not work on newer macOS due to new camera permissions, and the process will be force closed. There does not seem to be a viable workaround at present - help appreciated!

Changes in beta2

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

Please report any problems at https://github.com/praxis-live/support/issues

PraxisLIVE v5.0.0-beta-1

Compare
Choose a tag to compare
Pre-release

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. 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. Simply make the AppImage 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 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).

Known Issues

  • OpenGL window sometimes doesn't close on macOS when root is stopped. The old window is correctly closed and a new one created if started again. And the window is closed when stopping / cleaning the project.
  • On Windows, child processes of projects are sometimes not shutdown correctly when the project is stopped / cleaned.

Please report any problems at https://github.com/praxis-live/support/issues

PraxisLIVE v4.4.0

Compare
Choose a tag to compare

PraxisLIVE v4.4.0 primarily involves under-the-hood changes as we gear up towards PraxisLIVE v5. It also brings some helpful UI improvements and a major change in how containers work.

The bundled JDK in the default installers is still Java 8, although there is an experimental Windows installer with Java 11. There is no macOS bundle with JDK 11 yet due to Processing crashes found in testing. It is possible to use the Zip bundle with a JDK of choice for experimentation.

NB. Use of PraxisLIVE / praxislive without the space is now consistent, and reflected in installation folders and binary names. This should only affect you if you have custom shortcuts to the IDE.

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

PraxisLIVE v4.3.0

Compare
Choose a tag to compare

PraxisLIVE v4.3.0 brings optional support for running on and coding with Java 11, and the IDE platform is updated to Apache NetBeans 11.0. There are also some improvements for working with OpenGL, and some usability enhancements to the IDE.

The bundled JDK in the default installers is still Java 8, although there is an experimental Windows installer with Java 11. There is no macOS bundle with JDK 11 yet due to Processing crashes found in testing. It is possible to use the Zip bundle with a JDK of choice for experimentation.

NB. Use of PraxisLIVE / praxislive without the space is now consistent, and reflected in installation folders and binary names. This should only affect you if you have custom shortcuts to the IDE.

Changes

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.

PraxisLIVE v4.2.0

54b590d
Compare
Choose a tag to compare

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

Changes

PraxisCORE runtime

  • Core
    • Updated JNA library to v5.2.0
    • Added mapTo() to Linkable.Int and Linkable.Double` to allow conversion to objects
  • Tinkerforge
    • Updated Tinkerforge bindings library to v2.1.22
  • Video
    • Updated Processing library to v3.5.3, along with revised JOGL version (fixes OpenGL on some graphics cards, but with the potential for regression - please report an issue if affected).
    • Added new Processing square() and circle() method mappings in video:gl:p2d and video:gl:p3d, as well as equivalents in video:custom. (The new push() and pop() are not currently mapped as pushing and popping styles requires work to not break PraxisCORE's sharing of surfaces).
    • Updated GStreamer bindings library to gst1-java-core v1.0-beta2 (the bindings are maintained by PraxisLIVE, and a lot of work to stabilise and improve them has been sponsored over the last month).
    • Revised video:capture to use a top-level GStreamer pipeline rather than a bin when creating custom capture sources - fixes issues with using elements with dynamic pads like decodebin in custom sources.
    • Fix video:capture and video:player keeping a copy of the last frame when sources change - often see a quick flash of old content.

PraxisLIVE IDE

  • Graph editor
    • Automatically select and focus newly added or pasted components.
    • Improve keyboard actions for controls (.) and connections (~ and !) by automatically applying component field if selection exists, as well as preferring items that start with the provided text in the select lists.