Michael Sperone

composers-tool-kit

Composers' Tool Kit

IanniX

This project interacts with Max because of native OSC-link in our software. We also provide an example of additive synthesis with Max in our patches examples.

iannix

nakataka

It was created using all "Max", stand-alone applications for ambient music.

nagi-2

Nagi #2

ennio mazzon

micropony

MICROPONY

rtb24

MelloToneGen is a generative ambient music and noise machine application for OS X.

Built with Max/MSP, it runs as a native Mac application, and creates soothing, meditative soundscapes, using sounds of nature recorded in the Pacific Northwest, along with algorithmically-generated synthetic tones.

You can choose from multiple soundscape themes, created from layers of original field recordings. Along with that, mellow tones are generated, that evolve over time (especially enjoyable on headphones).

Having a non-repeating source of ambient sound can be beneficial in many situations. Focusing on work or creative tasks in a totally quiet space can be difficult. Similarly, it's hard to concentrate when listening to music with melodies or lyrics. MelloToneGen aims to strike a balance by providing more than just white noise, and avoiding melodic repetition.

mellotonegen-ambient-noise-generative-music-app-for-mac

MelloToneGen: Ambient Noise & Generative Music App for Mac

komak

max used for the conversion off x/y position on the touchpad to midi x/y cc. and for make the .app

komak-touchmid

komak touchmid

diablodale

This is a Max Jitter external for OpenNI on Windows and Mac OSx.

I caution everyone that OpenNI is dead. April 2014, the OpenNI website is closing. When this happens, there may be no legal place to download NITE (the essential component of OpenNI that does skeletal tracking). If you are on Windows, please use dp.kinect instead.

Configuration of OpenNI by an OpenNI XML configuration file; see OpenNI documentation for format

ImageMap of RGB24 output in a 4-plane char jitter matrix

DepthMap output in a 1-plan long, float32, or float64 jitter matrix

IrMap output in a 1-plan long, float32, or float64 jitter matrix

UserPixelMap output in a 1-plan long, float32, or float64 jitter matrix

Skeleton joints in an OSC, native max route, or legacy OSCeleton format

Skeleton events in an OSC, native max route, or legacy OSCeleton format (e.g. user seen, user lost, calibration success, etc.)

Values for user centers of mass and joints in OpenNI native, projective coordinate, or OSCeleton legacy "normalized" values

Attributes to filtering data based on position or orientation confidence, display or not the orientation data, and smooth skeleton data using OpenNI's smoothing API

Compiled as a Win32 and Mac OSx max/jitter external

https://github.com/diablodale/jit.openni/wiki is the location of the project documentation and setup instructions.

Example of some OSC joint output:
/userid/jointname x y z confidPosition [Xx Xy Xz Yx Yy Yz Zx Zy Zz orientPosition]

It has been casually tested with Max 5 and 6, SensorKinect, and OpenNI binaries on Windows and Mac OSx. If you find problems and can reproduce them with clear steps, I encourage you to open an issue at https://github.com/diablodale/jit.openni/issues

This external's output is very similar to jit.freenect.grab and therefore it can often be used in its place with small changes. My object outputs depth in mm and jit.freenect.grab outputs in cm. A simple math operation can resolve this. Note, my object does not provide the "raw" values of jit.freenect.grab; instead it provides the mm depth values via OpenNI.

The OSC skeleton data should be easy to use if you are familiar with OSCeleton.

I would like to see support for other generators (gestures, hand point, etc.) in the future added by myself or with the assistance of others.


jit-openni

jit.openni (inc. Kinect)

Ben Bracken

As of Max 8.1, we've taken the steps necessary to make Max compatible with Apple's new notarization standards. In our tests, things appear to be working well using Max 8.1 on Mac OS 10.15 beta. Despite these new complexities, Mac standalone developers should be able to distribute their applications if the the new Notarization guidelines are followed.

We understand first-hand how this change in Apple's security policy introduces inconvenience for the developer. We have worked hard to make it possible to build Max standalones that can run under the new Apple security polices, and appreciate any reports and examples where it does not work.

Read more about Apple notarization requirements: https://developer.apple.com/documentation/security/notarizing_your_app_before_distribution

In order to distribute a Max Standalone application that passes new Gatekeeper checks, these guidelines must be followed. However, Apple has stated that they are delaying some of these requirements until January 2020: https://developer.apple.com/news/?id=09032019a

The runtime application used in Max standalones is built with "Hardened Runtime" enabled, but developers of standalones will need to do the following in order to satisfy Apple's new requirements:

Install and make Xcode 10+ your active Xcode installation (use xcode-select if multiple versions are installed). Xcode 11 presumably works as well.

use the '--force' flag to force re-signing (overwriting Cycling '74 code signing)

use the '--deep' flag to sign the whole bundle. We have had some reports that this is enough, but other reports that indicate you may have to sign every framework, external object, dylib and any other executable binary that exists in the app bundle. We have found that this is necessary for the Max app itself. We recommend that you start with the --deep flag and see how far that gets you. If you want to try signing every framework, check out the forum post here: https://cycling74.com/forums/mac-standalone-codesigning-2021-update 

use a custom 'entitlements' file while signing, enabling whatever features the standalone may need (camera access, microphone access, etc). See the bottom of this article for an explanation of some of the entitlements we recommend using, and refer to this Apple documentation for even more information: https://developer.apple.com/documentation/bundleresources/entitlements

Although not explicitly required at the moment, we recommend using the '--timestamp' flag.

Terminal example: codesign -s [your developer ID] --options runtime --timestamp --force --deep --entitlements [path/to/app.entitlements] -f [path/to/standalone.app]

Upload your software to the Apple notary service using 'xcrun altool'. We recommend using a DMG or zip to distribute your standalone: https://developer.apple.com/documentation/xcode/notarizing_your_app_before_distribution/customizing_the_notarization_workflow#3087734

Terminal example: xcrun altool --notarize-app -f [path/to/standalone.<dmg|zip>] -t osx -u [Apple developer user name] -p [your password] -primary-bundle-id [com.yourcompany.yourapp] --asc-provider [your 'team' name]

After successful notarization, 'staple' the returned ticket to your standalone using 'xcrun stapler': https://developer.apple.com/documentation/xcode/notarizing_your_app_before_distribution/customizing_the_notarization_workflow#3087720

Note: if you use a .zip file to distribute your standalone, after notarizing, you will need to unzip, then perform the staple on the .app itself, then re-zip. 

Terminal example: xcrun stapler staple -v [path/to/standalone.<dmg|app>]

It currently still is possible to notarize old standalones for use on Catalina by following similar instructions as above: https://developer.apple.com/documentation/xcode/notarizing_your_app_before_distribution#3087722

For those who simply wish to share standalone apps without going through the notarization, un-notarizized applications should be able to bypass Gatekeeper as before (ie right-clicking the app to open).   

If you do run into issues, please do not hesitate to drop us a note. We understand how important this option is for those who want to distribute Max patches using the Standalone mechanism. As Apple's requirements change, we fully plan on making the adjustments needed to continue to allow users to do so, if possible.

Here is a cheat sheet that might help you determine what may or may not be needed in an Entitlements file. Again, refer to the Apple Developer documentation for more details.

<key>com.apple.security.automation.apple-events</key>
<true/>

This  is necessary for triggering apple-events. In addition to any use of  third party AppleScript objects, this may be necessary for certain  VST/AU plugins and their particular authorization systems (though more info is needed on this point). 

<key>com.apple.security.cs.allow-dyld-environment-variables</key>
<true/>

This  entitlement allows for using alternate locations for libraries as set  by environment variables. This may not be necessary for many standalones, though some may need this for advanced workflows. 

<key>com.apple.security.cs.allow-jit</key>
<true/>

This entitlement allows for using JIT compiled code--e.g. CEF, lua, Java, and Javascript objects could make use of this. 

<key>com.apple.security.cs.allow-unsigned-executable-memory</key>
<true/>

This  is a superset which is necessary for many of the above instances,  including Gen, which do not specifically use newer JIT specific flags for  memory mapping executable pages. 

<key>com.apple.security.cs.disable-library-validation</key>
<true/>

This is necessary to load any 3rd party externals or VST/AU plug-ins that have not been notarized.  

<key>com.apple.security.device.audio-input</key>
<true/>

This  is necessary to initialize the audio driver and open audio input. 

<key>com.apple.security.device.camera</key>
<true/>

This is necessary to open the camera input. 

catalina.png

Mac OS 10.15 (Catalina) support in Max 8.1 and notarizing Mac standalone applications.

max-8-1-mac-os-10-15-catalina-support-and-notarization

Max 8.1: Mac OS 10.15 Catalina Support and Notarization

oli larkin

Dan Nigrin

James Howard Young

Many people enjoy sharing their Max creations with others in the form of a standalone application. To reach a broader audience, we would like to be able to submit standalone applications to Apple’s Mac App Store.  Regular Cycling ’74 forum readers will likely recognize a long running thread called “Max apps in new Apple Mac App Store?” that was started in 2010 and still receives new postings.  That thread documents our efforts, together with Cycling ‘74, to navigate Apple’s various guidelines and restrictions in order to get Max standalones into the Mac App Store.

Between that thread and a recent story that appeared on Create Digital Music, we’ve received lots of requests for more information on the process. This article will attempt to fill in the details so other Max creators can get in on the App Store action!

First off, you must use Max 6 to create a standalone that will satisfy Apple’s requirements, primarily because in Max 6, app-specific preference files are saved in a location permitted by Apple.

It’s also probably a good idea to make sure that your standalone has some of the basics down (custom icon, appropriate menus, etc...) before embarking on the steps below. Dan covered many of these topics in his 2011 Expo ‘74 presentation entitled “Making A Slick Max Standalone." The slides for the presentation are available here.

After you are in the program, you will be required to follow Apple’s guidelines before your application will be accepted for inclusion. Here are some of the rules that are most likely to affect Max-based applications:

No use of Java (so no mxj use in your standalone)

No demo or limited functionality versions of your app

No file access (read or write) beyond “approved” locations, without specific end-user request for such (via file dialog box for example).  These approved locations are:


To ensure that your application stores its preferences in one of these approved locations, do the following:

Include a standalone object in your patch.

Open the inspector for the standalone object, and change the “Preferences File Name” attribute to the same name as your application. For example, if your application will be called My Cool App, the Preferences File Name must also be My Cool App. This will create a folder the first time your app is launched at ~/Library/Application Support/My Cool App, and all Max’s will subsequently be stored within that folder. You can also use this folder if your app needs to store any other files (such as a custom preferences file).

If you are using any third party Max externals, they may contain PowerPC (PPC) code.  which is not allowed in the App Store.

If you want to verify whether you have any third-party externals containing PowerPC code, you can use the following command in the Terminal that will list any problematic objects. Before executing the command, set the current directory to a folder containing your third-party externals. 

find . -type f -exec lipo -info '{}' 2>/dev/null \; | grep ppc | grep MacOS | sed -e 's/.*MacOS\///g' -e 's/ are.*//g'

To get rid of the PowerPC code, you can use an application called TrimTheFat; just drop the .mxo external in question onto the TrimTheFat icon, and it will strip away the PowerPC part of the binaries. You’ll need to do this before building your application, because a Max standalone stores external object executable code in a proprietary format that can’t easily be modified. However, you need only remove PowerPC code once.

By the way, if you are using other people’s work, check to make sure the license terms are compatible with the App Store’s, and that you are allowed to use it in a closed source product (if that is your intention).

The next few changes involve tweaks within your application’s bundle folder. You’ll need to make these changes after building your standalone.

To access the bundle, ctrl- or right-click on your application’s icon in the Finder, and choose Show Package Contents. This will open a new window that shows you the set of files inside the application bundle, which is actually a folder. All the items in an application bundle are inside a folder called Contents.

Apple apparently doesn’t like underscore (_) characters to be part of any bundle identifier. Within the support folder inside the Contents folder, open the ad folder where you’ll find the Core Audio driver object called ad_coreaudio.mxo. Ctrl- or right-click on the .mxo file and choose Show Package Contents. Double-click on the Info.plist file, at Contents/Info.plist and change the Bundle Identifier from com.cycling74.ad_coreaudio to com.cycling74.adcoreaudio.

You also have to add some specific entries within your app’s Info.plist file located in the Contents folder. These include a valid bundle ID, bundle version, copyright string, and application category (LSApplicationCategoryType). More information is available in the Mac App Store Developer document, in the “Requirements” section. You may wish to copy the Info.plist file to another location once you modify it, then you can replace the standard one Max puts into your standalone if you ever want to make an updated version of your application and submit it to Apple.

Once you’ve got your app completely ready to go, you need to “sign” and package it using certificates that Apple issues to you.  More information on how to get those certificates on your computer is available on the Apple Developer site.

Once you’ve downloaded the certificates to your computer, you’re ready to sign your app. Within your standalone, you’ll need to sign the .app itself as well as any Max frameworks, audio drivers, midi drivers and/or extensions included within your application bundle. Here are examples of the code signing commands (to be run within the Terminal) for an app that includes the Core Audio audio driver, Core MIDI driver, and the setplugpath extension:

codesign -f -s "3rd Party Mac Developer Application: DEVELOPER_NAME" PATH_TO_YOUR_APP

codesign -f -s "3rd Party Mac Developer Application: DEVELOPER_NAME" PATH_TO_YOUR_APP/Contents/Frameworks/MaxAPI.framework/Versions/A

codesign -f -s "3rd Party Mac Developer Application: DEVELOPER_NAME" PATH_TO_YOUR_APP/Contents/Frameworks/MaxAudioAPI.framework/Versions/A

codesign -f -s "3rd Party Mac Developer Application: DEVELOPER_NAME" PATH_TO_YOUR_APP/Contents/support/ad/ad_coreaudio.mxo

codesign -f -s "3rd Party Mac Developer Application: DEVELOPER_NAME" PATH_TO_YOUR_APP/Contents/support/mididrivers/coremidi.mxo

codesign -f -s "3rd Party Mac Developer Application: DEVELOPER_NAME" PATH_TO_YOUR_APP/Contents/support/extensions/setplugpath.mxo

Once the signing is done, you need to package your application using the productbuild command, again using a Terminal command and with an Apple-provided certificate. Here is example that’s worked for us. This command will place the final package file at the root of your home directory:

productbuild \
--component PATH_TO_YOUR_APP /Applications \
--sign "3rd Party Mac Developer Installer: DEVELOPER_NAME" \
--product "PATH_TO_YOUR_APP/Contents/Info.plist" APP_NAME.pkg

Now all that’s left is application screenshots and other details which you’ll need to provide on Apple’s iTunesConnect site, and uploading the .pkg file you created in the last step using the Application Loader utility, which should be provided within Apple’s Developer tools on your hard drive.

We hope this covers most of the unique aspects of getting a Max application distributed via Apple's Mac App Store – we look forward to seeing more Max creations available there!

Oli Larkin: pMix - A sound design, composition and performance tool that allows you to morph between VST plugin presets using an intuitive graphical interface.

Dan Nigrin: Audio Plugin Player - A lightweight VST and AU instrument plugin host, that allows you to play these instruments using either your mouse, computer keyboard, or MIDI device, with support for VST and AU effects too. 

Dan Nigrin: General MIDI Player - An easy way to turn your Mac into an instrument, using its built-in General MIDI support, with options for mouse, computer keyboard, or MIDI input.

James Howard Young: TapNTempo - A fully featured metronome that offers customizable sounds, real-time tempo tapping, and beat and division capabilities.

get-your-max-standalone-on-apple’s-mac-app-store

Your Max Standalone on Mac App Store

Peter McCulloch

PM.Chamberlin~ is a Chamberlin state-variable filter.  It contains two extra modes (peak and notch), and is over-sampled so it supports cutoff frequencies over up to roughly 80% of the Nyquist frequency.

The cutoff can be specified in MIDI or frequency values, and the filter can self-oscillate.  The filter has a built-in saturation.  The volume of the self-oscillation is fixed, so pre-and-post gain can be used to adjust the mix of the resonant peak.

This release is only for Mac, and the SDK was for 10.5, so it may not work on 10.4 machines.  I don't have Windows, but if anyone is interested in using this on Windows please contact me and we'll see what we can do.


Search Results