mfp 0.8.5

MFP -- Music For Programmers, version 0.8.5

I'm happy to announce the next release in the MFP 0.8 series,
including a new scalable UI for high DPI displays and other
improvements and bug fixes.

A summary of changes is below. Please see the GitHub project page
for complete details:

http://github.com/bgribble/mfp

I still recommend cloning and building from source. The build
process is improved and does a better job of isolating the MFP
install into the --prefix destination.

If you simply can't get the build dependencies working, I have
made a start on a CD process using Github Actions. There is a
binary package for amd64 architectures (most AMD and Intel
processors) with an install script that should be built and
associated with the release. Versions of the installable packages
are built for Python 3.10, 3.11, 3.12, and 3.13; pick whichever
one is appropriate for you. Since MFP includes both Python and C
components, I am not very confident that this binary package will
work. Please let me know if you have success (or failure) with
it.

Significant changes since release v0.8.4

• Scalable UI for high DPI displays
  • Port to imgui_bundle 1.92.3, which pulls in scalability work
    from Dear Imgui
  • Scalable fonts throughout, so no more pixelated ProggyClean
  • Magnification menu setting and command line option to globally
    change UI magnification
• Fixes for DSP objects with dynamic numbers of inlets/outlets ([faust~],
  [buffer~], [plugin~]) to make save/load work consistently
• Improvements to the [buffer~] processor
  • Allow retrigger before the end of the buffer/region
  • Configurable debounce and crossfade for retriggering
• Bug fixes in UI
  • TAB to select next works more as expected
  • Save/restore "panel mode" state for patches
  • Object rename didn't work as expected
  • Make button dispalys more consistent, respect size constraints
  • Clip background color in text elements (comments)
  • Improve rendering and positioning of via elements

About MFP

MFP is an environment for visually composing computer programs,
with an emphasis on music and real-time audio synthesis and
analysis. It's very much inspired by Miller Puckette's Pure Data
(Pd) and Max/MSP, with a bit of LabView and TouchOSC for good
measure. It is targeted at musicians, recording engineers, and
software developers who like the "patching" dataflow metaphor for
coding up audio synthesis, processing, and analysis.

MFP is a completely new code base, written in Python and C. It
has been under development by a solo developer (me!), as a
spare-time project for several years.

Compared to Pure Data, its nearest relative, MFP is superficially
pretty similar but differs in a few key ways:

• MFP uses Python data natively. Any literal data entered in the
  UI is parsed by the Python evaluator, and any Python value is a
  legitimate "message" on the dataflow network. This makes it much
  easier to make patches that work like conventional "programs".

• MFP provides fairly raw access to Python constructs if
  desired. For example, a built-in editor allows live coding of
  Python functions as patch elements at runtime.

• Name resolution and namespacing are addressed more robustly,
  with explicit support for lexical scoping. This allows patches
  to have a dynamic number of inputs and outputs, with hygienic
  layer copying preserving the lexical structure of each "voice"

• The UI is largely keyboard-driven, with a modal input system
  that feels a bit like vim. The graphical presentation is a
  single-window style with layers and a tiled workspace rather
  than multiple windows.

• There is fairly deep integration of Open Sound Control (OSC), with
  every patch element having an OSC address and the ability to learn
  any other desired address. MIDI controller learning is also robustly
  supported.

• MFP has just a fraction of the builtin and addon functionality
  provided by Pd. It's not up to being a replacement except in
  limited cases!

The code and issue tracker are hosted on GitHub:

https://github.com/bgribble/mfp

Help can be found in the app; I recommend starting with the
Tutorial and proceeding to the Reference mentioned in the Help
menu.

You can find two white papers about MFP (one accepted to the 2013
edition of the Linux Audio Conference, and one submitted for the
2025 edition), some sample patches, and a few other bits of
documentation in the doc directory of the GitHub repo. The
README files at the top level of the source tree contain
dependency, build, and getting-started information.

Where's it going?

I've been working on MFP as a spare time project for almost 14
years now. The likelihood that it will ever have more than a few
users is low. Luckily, that doesn't bother me much; MFP is a
tool I am building mainly for my own use and education.

That being said, if there's something about it that appeals to
you, I welcome your interest and participation.

Thanks,
Bill Gribble grib@billgribble.com

mfp 0.8.4

MFP -- Music For Programmers, version 0.8.4

I'm happy to announce a followup release to 0.8.3,
including bug fixes and new features I added in the runup to
LAC-2025.

A summary of changes is below. Please see the GitHub project page
for complete details:

http://github.com/bgribble/mfp

I still recommend cloning and building from source. The build
process is improved and does a better job of isolating the MFP
install into the --prefix destination.

If you simply can't get the build dependencies working, I have
made a start on a CD process using Github Actions. There is a
binary package for amd64 architectures (most AMD and Intel
processors) with an install script that should be built and
associated with the release. Versions of the installable packages
are built for Python 3.10, 3.11, 3.12, and 3.13; pick whichever
one is appropriate for you. Since MFP includes both Python and C
components, I am not very confident that this binary package will
work. Please let me know if you have success (or failure) with
it.

Significant changes since release v0.8.3

• Add [table] plot object. This is an interactive editable barchart similar
  to [itable] in Max
• Add [messagerec] builtin. This is a clocked record/playback sequencer that
  can be used to record any kind of message.
• Added infrastructure for preset save/load via the @preset method.
  • Send the message @preset("preset name", save=True) to an object to create
    or save a preset
  • Send @preset("preset name") to load the preset
  • Send to a via named self will save a preset for the whole patch and all children
• Support slices as element addresses in [get] and [set!]
• Fix bugs in MIDI event handling
• Fix bugs in panel-mode displays
• Fix bugs in [faust~] creation

About MFP

MFP is an environment for visually composing computer programs,
with an emphasis on music and real-time audio synthesis and
analysis. It's very much inspired by Miller Puckette's Pure Data
(Pd) and Max/MSP, with a bit of LabView and TouchOSC for good
measure. It is targeted at musicians, recording engineers, and
software developers who like the "patching" dataflow metaphor for
coding up audio synthesis, processing, and analysis.

MFP is a completely new code base, written in Python and C. It
has been under development by a solo developer (me!), as a
spare-time project for several years.

Compared to Pure Data, its nearest relative, MFP is superficially
pretty similar but differs in a few key ways:

• MFP uses Python data natively. Any literal data entered in the
  UI is parsed by the Python evaluator, and any Python value is a
  legitimate "message" on the dataflow network. This makes it much
  easier to make patches that work like conventional "programs".

• MFP provides fairly raw access to Python constructs if
  desired. For example, a built-in editor allows live coding of
  Python functions as patch elements at runtime.

• Name resolution and namespacing are addressed more robustly,
  with explicit support for lexical scoping. This allows patches
  to have a dynamic number of inputs and outputs, with hygienic
  layer copying preserving the lexical structure of each "voice"

• The UI is largely keyboard-driven, with a modal input system
  that feels a bit like vim. The graphical presentation is a
  single-window style with layers and a tiled workspace rather
  than multiple windows.

• There is fairly deep integration of Open Sound Control (OSC), with
  every patch element having an OSC address and the ability to learn
  any other desired address. MIDI controller learning is also robustly
  supported.

• MFP has just a fraction of the builtin and addon functionality
  provided by Pd. It's not up to being a replacement except in
  limited cases!

The code and issue tracker are hosted on GitHub:

https://github.com/bgribble/mfp

Help can be found in the app; I recommend starting with the
Tutorial and proceeding to the Reference mentioned in the Help
menu.

You can find two white papers about MFP (one accepted to the 2013
edition of the Linux Audio Conference, and one submitted for the
2025 edition), some sample patches, and a few other bits of
documentation in the doc directory of the GitHub repo. The
README files at the top level of the source tree contain
dependency, build, and getting-started information.

Where's it going?

I've been working on MFP as a spare time project for almost 14
years now. The likelihood that it will ever have more than a few
users is low. Luckily, that doesn't bother me much; MFP is a
tool I am building mainly for my own use and education.

That being said, if there's something about it that appeals to
you, I welcome your interest and participation.

Thanks,
Bill Gribble grib@billgribble.com

mfp 0.8.3

MFP -- Music For Programmers, version 0.8.3

I'm happy to announce a followup release to 0.8.2,
including fixes for several bugs that surfaced post-release.

A summary of changes is below. Please see the GitHub project page
for complete details:

http://github.com/bgribble/mfp

I still recommend cloning and building from source. The build
process is improved and does a better job of isolating the MFP
install into the --prefix destination.

If you simply can't get the build dependencies working, I have
made a start on a CD process using Github Actions. There is a
binary package for amd64 architectures (most AMD and Intel
processors) with an install script that should be built and
associated with the release. Versions of the installable packages
are built for Python 3.10, 3.11, 3.12, and 3.13; pick whichever
one is appropriate for you. Since MFP includes both Python and C
components, I am not very confident that this binary package will
work. Please let me know if you have success (or failure) with
it.

Significant changes since release v0.8.2

The following bug tickets are resolved with this release:

• #332: Custom code editing broken with the release of imgui_bundle 0.6.2

• #333: Output of LV2 MIDI events fails for system events

• #334: LV2 port types not initialized correctly for inlet/outlet

• #335: Multiple outputs for a processor cause errors

• #336: String buffer overrun in LV2 embed

• #338: Image-not-found causes crash in Markdown

About MFP

MFP is an environment for visually composing computer programs,
with an emphasis on music and real-time audio synthesis and
analysis. It's very much inspired by Miller Puckette's Pure Data
(Pd) and Max/MSP, with a bit of LabView and TouchOSC for good
measure. It is targeted at musicians, recording engineers, and
software developers who like the "patching" dataflow metaphor for
coding up audio synthesis, processing, and analysis.

MFP is a completely new code base, written in Python and C. It
has been under development by a solo developer (me!), as a
spare-time project for several years.

Compared to Pure Data, its nearest relative, MFP is superficially
pretty similar but differs in a few key ways:

• MFP uses Python data natively. Any literal data entered in the
  UI is parsed by the Python evaluator, and any Python value is a
  legitimate "message" on the dataflow network. This makes it much
  easier to make patches that work like conventional "programs".

• MFP provides fairly raw access to Python constructs if
  desired. For example, a built-in editor allows live coding of
  Python functions as patch elements at runtime.

• Name resolution and namespacing are addressed more robustly,
  with explicit support for lexical scoping. This allows patches
  to have a dynamic number of inputs and outputs, with hygienic
  layer copying preserving the lexical structure of each "voice"

• The UI is largely keyboard-driven, with a modal input system
  that feels a bit like vim. The graphical presentation is a
  single-window style with layers and a tiled workspace rather
  than multiple windows.

• There is fairly deep integration of Open Sound Control (OSC), with
  every patch element having an OSC address and the ability to learn
  any other desired address. MIDI controller learning is also robustly
  supported.

• MFP has just a fraction of the builtin and addon functionality
  provided by Pd. It's not up to being a replacement except in
  limited cases!

The code and issue tracker are hosted on GitHub:

https://github.com/bgribble/mfp

Help can be found in the app; I recommend starting with the
Tutorial and proceeding to the Reference mentioned in the Help
menu.

You can find two white papers about MFP (one accepted to the 2013
edition of the Linux Audio Conference, and one submitted for the
2025 edition), some sample patches, and a few other bits of
documentation in the doc directory of the GitHub repo. The
README files at the top level of the source tree contain
dependency, build, and getting-started information.

Where's it going?

I've been working on MFP as a spare time project for almost 14
years now. The likelihood that it will ever have more than a few
users is low. Luckily, that doesn't bother me much; MFP is a
tool I am building mainly for my own use and education.

That being said, if there's something about it that appeals to
you, I welcome your interest and participation.

Thanks,
Bill Gribble grib@billgribble.com

mfp 0.8.2

MFP -- Music For Programmers, version 0.8.2

I'm happy to announce a followup release to 0.8.1,
with several key bugfixes and enhancements. The focus on this
release is on the new "Panel Mode", a curated patch display
mode similar to Max's Presentation Mode.

A summary of changes is below. Please see the GitHub project page
for complete details:

http://github.com/bgribble/mfp

I still recommend cloning and building from source. The build
process is improved and does a better job of isolating the MFP
install into the --prefix destination.

If you simply can't get the build dependencies working, I have
made a start on a CD process using Github Actions. There is a
binary package for amd64 architectures (most AMD and Intel
processors) with an install script that should be built and
associated with the release. Versions of the installable packages
are built for Python 3.10, 3.11, 3.12, and 3.13; pick whichever
one is appropriate for you. Since MFP includes both Python and C
components, I am not very confident that this binary package will
work. Please let me know if you have success (or failure) with
it.

Significant changes since release v0.8.1

• #326: Add Panel Mode to patches. C-ESC toggles Panel Mode on and off
  for a patch display.
• Add the "Enable panel display" setting to all patch objects (in the
  Object tab of the right-side info panel). Objects with panel display
  enabled have different (x, y) position coordinates for Panel and Patch
  mode.
• #327: Support Markdown image loading with the ![title](filename) syntax.
  Image files are searched for in the MFP load path, which can be added to with
  the -p <path> command line option.
• Preserve connections into and out of a [faust~] object across Faust
  code changes.
• Fix a bug that dropped some [faust~] parameter inlets
• Update imgui_bundle to version 1.6.3, fixing a problem that inserted
  extra space into matching strings when using / for interactive search
• Update doc/lac2025/ with the final edits of the LAC-2025 paper

About MFP

MFP is an environment for visually composing computer programs,
with an emphasis on music and real-time audio synthesis and
analysis. It's very much inspired by Miller Puckette's Pure Data
(Pd) and Max/MSP, with a bit of LabView and TouchOSC for good
measure. It is targeted at musicians, recording engineers, and
software developers who like the "patching" dataflow metaphor for
coding up audio synthesis, processing, and analysis.

MFP is a completely new code base, written in Python and C. It
has been under development by a solo developer (me!), as a
spare-time project for several years.

Compared to Pure Data, its nearest relative, MFP is superficially
pretty similar but differs in a few key ways:

• MFP uses Python data natively. Any literal data entered in the
  UI is parsed by the Python evaluator, and any Python value is a
  legitimate "message" on the dataflow network. This makes it much
  easier to make patches that work like conventional "programs".

• MFP provides fairly raw access to Python constructs if
  desired. For example, a built-in editor allows live coding of
  Python functions as patch elements at runtime.

• Name resolution and namespacing are addressed more robustly,
  with explicit support for lexical scoping. This allows patches
  to have a dynamic number of inputs and outputs, with hygienic
  layer copying preserving the lexical structure of each "voice"

• The UI is largely keyboard-driven, with a modal input system
  that feels a bit like vim. The graphical presentation is a
  single-window style with layers and a tiled workspace rather
  than multiple windows.

• There is fairly deep integration of Open Sound Control (OSC), with
  every patch element having an OSC address and the ability to learn
  any other desired address. MIDI controller learning is also robustly
  supported.

• MFP has just a fraction of the builtin and addon functionality
  provided by Pd. It's not up to being a replacement except in
  limited cases!

The code and issue tracker are hosted on GitHub:

https://github.com/bgribble/mfp

Help can be found in the app; I recommend starting with the
Tutorial and proceeding to the Reference mentioned in the Help
menu.

You can find two white papers about MFP (one accepted to the 2013
edition of the Linux Audio Conference, and one submitted for the
2025 edition), some sample patches, and a few other bits of
documentation in the doc directory of the GitHub repo. The
README files at the top level of the source tree contain
dependency, build, and getting-started information.

Where's it going?

I've been working on MFP as a spare time project for almost 14
years now. The likelihood that it will ever have more than a few
users is low. Luckily, that doesn't bother me much; MFP is a
tool I am building mainly for my own use and education.

That being said, if there's something about it that appeals to
you, I welcome your interest and participation.

Thanks,
Bill Gribble grib@billgribble.com

mfp 0.8.1

MFP -- Music For Programmers, version 0.8.1

I'm happy to announce a followup release to 0.8.0,
with several key bugfixes and enhancements. The focus on this
release is on MIDI events and use of MFP as an LV2 plugin.

A summary of changes is below. Please see the GitHub project page
for complete details:

http://github.com/bgribble/mfp

I still recommend cloning and building from source. The build
process is improved and does a better job of isolating the MFP
install into the --prefix destination.

If you simply can't get the build dependencies working, I have
made a start on a CD process using Github Actions. There is a
binary package for amd64 architectures (most AMD and Intel
processors) with an install script that should be built and
associated with the release. Versions of the installable packages
are built for Python 3.10, 3.11, 3.12, and 3.13; pick whichever
one is appropriate for you. ince MFP includes both Python and C
components, I am not very confident that this binary package will
work. Please let me know if you have success (or failure) with
it.

Significant changes since release v0.8.0

• Multiple instances of MFP as an LV2 plugin in the same host now
  work as expected. All edit windows will share the same UI; the
  "DSP Context" field in the Info panel will distinguish between
  the various instances and hosts.

• Support for the MIDI port type in LV2 plugins

• Message (non-signal) inlets and outlets in patches to be saved
  as LV2 plugins can now have their type (MIDI or float) and
  bounds edited in the Params tab of the object inspector

• MFP should now work with both Wayland and Xorg sessions, using
  the XDG_SESSION_TYPE environment variable to distinguish

• A broader range of MIDI event types are recognized, including
  clock and song position messages

• The ALSA MIDI bindings have been changed from alsaseq to
  python-alsa-midi, which supports a wider variety of events
  and is in "active maintenance" mode

• New builtin midi.time to decode MIDI SPP, Start, Stop,
  Continue, Clock, and QFRAME events to produce hh:mm:ss:ff and
  bar:beat:clock time outputs

About MFP

MFP is an environment for visually composing computer programs,
with an emphasis on music and real-time audio synthesis and
analysis. It's very much inspired by Miller Puckette's Pure Data
(Pd) and Max/MSP, with a bit of LabView and TouchOSC for good
measure. It is targeted at musicians, recording engineers, and
software developers who like the "patching" dataflow metaphor for
coding up audio synthesis, processing, and analysis.

MFP is a completely new code base, written in Python and C. It
has been under development by a solo developer (me!), as a
spare-time project for several years.

Compared to Pure Data, its nearest relative, MFP is superficially
pretty similar but differs in a few key ways:

• MFP uses Python data natively. Any literal data entered in the
  UI is parsed by the Python evaluator, and any Python value is a
  legitimate "message" on the dataflow network. This makes it much
  easier to make patches that work like conventional "programs".

• MFP provides fairly raw access to Python constructs if
  desired. For example, a built-in editor allows live coding of
  Python functions as patch elements at runtime.

• Name resolution and namespacing are addressed more robustly,
  with explicit support for lexical scoping. This allows patches
  to have a dynamic number of inputs and outputs, with hygienic
  layer copying preserving the lexical structure of each "voice"

• The UI is largely keyboard-driven, with a modal input system
  that feels a bit like vim. The graphical presentation is a
  single-window style with layers and a tiled workspace rather
  than multiple windows.

• There is fairly deep integration of Open Sound Control (OSC), with
  every patch element having an OSC address and the ability to learn
  any other desired address. MIDI controller learning is also robustly
  supported.

• MFP has just a fraction of the builtin and addon functionality
  provided by Pd. It's not up to being a replacement except in
  limited cases!

The code and issue tracker are hosted on GitHub:

https://github.com/bgribble/mfp

Help can be found in the app; I recommend starting with the
Tutorial and proceeding to the Reference mentioned in the Help
menu.

You can find two white papers about MFP (one accepted to the 2013
edition of the Linux Audio Conference, and one submitted for the
2025 edition), some sample patches, and a few other bits of
documentation in the doc directory of the GitHub repo. The
README files at the top level of the source tree contain
dependency, build, and getting-started information.

Where's it going?

I've been working on MFP as a spare time project for almost 14
years now. The likelihood that it will ever have more than a few
users is low. Luckily, that doesn't bother me much; MFP is a
tool I am building mainly for my own use and education.

That being said, if there's something about it that appeals to
you, I welcome your interest and participation.

Thanks,
Bill Gribble grib@billgribble.com

mfp 0.8.0

MFP -- Music For Programmers, version 0.8

I am pleased to announce a new version of MFP including numerous
new features and improvements. The major "deliverable" of this
release is a new UI backend built on
Dear ImGUI, which
replaces the older UI built on Gtk/Clutter.

A summary of changes is below. Please see the GitHub project page
for complete details:

http://github.com/bgribble/mfp

I still recommend cloning and building from source. The build
process is improved and does a better job of isolating the MFP
install into the --prefix destination.

If you simply can't get the build dependencies working, I have
made a start on a CD process using Github Actions. There is a
binary package for amd64 architectures (most AMD and Intel
processors) with an install script that should be built and
associated with the release. Versions of the installable packages
are built for Python 3.10, 3.11, 3.12, and 3.13; pick whichever
one is appropriate for you. ince MFP includes both Python and C
components, I am not very confident that this binary package will
work. Please let me know if you have success (or failure) with
it.

Significant changes since release v0.7

• A new UI built using Dear ImGUI.
  Improvements include:

  • A menu system reflecting most available keyboard actions

  • A tiled workspace manager enabling multiple patches to be
    open and editable simultaneously

  • New options for 2D plotting, including bar charts and
    histograms

  • Object info editor allowing direct access to properties
    and style parameters for patch elements

  • Search/filter in the Log tab

  • Text comments can be formatted with Markdown

• Improved live-coding support for Python via the "Custom code"
  editor

• Custom DSP coding (live or offline) with Faust, via the new
  [faust~] builtin

• An interactive help system, not yet completely populated with
  documentation but at least underway.

About MFP

MFP is an environment for visually composing computer programs,
with an emphasis on music and real-time audio synthesis and
analysis. It's very much inspired by Miller Puckette's Pure Data
(Pd) and Max/MSP, with a bit of LabView and TouchOSC for good
measure. It is targeted at musicians, recording engineers, and
software developers who like the "patching" dataflow metaphor for
coding up audio synthesis, processing, and analysis.

MFP is a completely new code base, written in Python and C. It
has been under development by a solo developer (me!), as a
spare-time project for several years.

Compared to Pure Data, its nearest relative, MFP is superficially
pretty similar but differs in a few key ways:

• MFP uses Python data natively. Any literal data entered in the
  UI is parsed by the Python evaluator, and any Python value is a
  legitimate "message" on the dataflow network. This makes it much
  easier to make patches that work like conventional "programs".

• MFP provides fairly raw access to Python constructs if
  desired. For example, a built-in editor allows live coding of
  Python functions as patch elements at runtime.

• Name resolution and namespacing are addressed more robustly,
  with explicit support for lexical scoping. This allows patches
  to have a dynamic number of inputs and outputs, with hygienic
  layer copying preserving the lexical structure of each "voice"

• The UI is largely keyboard-driven, with a modal input system
  that feels a bit like vim. The graphical presentation is a
  single-window style with layers and a tiled workspace rather
  than multiple windows.

• There is fairly deep integration of Open Sound Control (OSC), with
  every patch element having an OSC address and the ability to learn
  any other desired address. MIDI controller learning is also robustly
  supported.

• MFP has just a fraction of the builtin and addon functionality
  provided by Pd. It's not up to being a replacement except in
  limited cases!

The code and issue tracker are hosted on GitHub:

https://github.com/bgribble/mfp

Help can be found in the app; I recommend starting with the
Tutorial and proceeding to the Reference mentioned in the Help
menu.

You can find two white papers about MFP (one accepted to the 2013
edition of the Linux Audio Conference, and one submitted for the
2025 edition), some sample patches, and a few other bits of
documentation in the doc directory of the GitHub repo. The
README files at the top level of the source tree contain
dependency, build, and getting-started information.

Where's it going?

I've been working on MFP as a spare time project for almost 14
years now. The likelihood that it will ever have more than a few
users is low. Luckily, that doesn't bother me much; MFP is a
tool I am building mainly for my own use and education.

That being said, if there's something about it that appeals to
you, I welcome your interest and participation.

Thanks,
Bill Gribble grib@billgribble.com

mfp 0.8.0rc1

MFP -- Music For Programmers, version 0.8

I am pleased to announce a new version of MFP including numerous
new features and improvements. The major "deliverable" of this
release is a new UI backend built on Dear ImGUI, which
replaces the older UI built on Gtk/Clutter.

A summary of changes is below. Please see the GitHub project page
for complete details:

http://github.com/bgribble/mfp

I still recommend cloning and building from source. The build
process is improved and does a better job of isolating the MFP
install into the --prefix destination.

If you simply can't get the build dependencies working, I have
made a start on a CD process using Github Actions. There is a
binary package for amd64 architectures (most AMD and Intel
processors) with an install script that should be built and
associated with the release. Since MFP includes both Python and C
components, I am not confident that this binary package will
work; please let me know if you have success (or failure) with
it.

Significant changes since release v0.7

• A new UI built using Dear ImGUI. Improvements include:

  • A menu system reflecting most available keyboard actions

  • A tiled workspace manager enabling multiple patches to be
    open and editable simultaneously

  • New options for 2D plotting, including bar charts and
    histograms

  • Object info editor allowing direct access to properties
    and style parameters for patch elements

  • Search/filter in the Log tab

  • Text comments can be formatted with Markdown

• Improved live-coding support for Python via the "Custom code"
  editor

• Custom DSP coding (live or offline) with Faust, via the new
  [faust~] builtin

• An interactive help system, not yet completely populated with
  documentation but at least underway.

About MFP

MFP is an environment for visually composing computer programs,
with an emphasis on music and real-time audio synthesis and
analysis. It's very much inspired by Miller Puckette's Pure Data
(pd) and Max/MSP, with a bit of LabView and TouchOSC for good
measure. It is targeted at musicians, recording engineers, and
software developers who like the "patching" dataflow metaphor for
coding up audio synthesis, processing, and analysis.

MFP is a completely new code base, written in Python and C. It
has been under development by a solo developer (me!), as a
spare-time project for several years.

Compared to Pure Data, its nearest relative, MFP is superficially
pretty similar but differs in a few key ways:

• MFP uses Python data natively. Any literal data entered in the
  UI is parsed by the Python evaluator, and any Python value is a
  legitimate "message" on the dataflow network. This makes it much
  easier to make patches that work like conventional "programs".

• MFP provides fairly raw access to Python constructs if
  desired. For example, a built-in editor allows live coding of
  Python functions as patch elements at runtime.

• Name resolution and namespacing are addressed more robustly,
  with explicit support for lexical scoping. This allows patches
  to have a dynamic number of inputs and outputs, with hygienic
  layer copying preserving the lexical structure of each "voice"

• The UI is largely keyboard-driven, with a modal input system
  that feels a bit like vim. The graphical presentation is a
  single-window style with layers and a tiled workspace rather
  than multiple windows.

• There is fairly deep integration of Open Sound Control (OSC), with
  every patch element having an OSC address and the ability to learn
  any other desired address. MIDI controller learning is also robustly
  supported.

• MFP has just a fraction of the builtin and addon functionality
  provided by PD. It's not up to being a replacement except in
  limited cases!

The code and issue tracker are hosted on GitHub:

https://github.com/bgribble/mfp

You can find the LAC-2013 paper and accompanying screenshots,
some sample patches, and a few other bits of documentation in the
doc directory of the GitHub repo. The README files at the top
level of the source tree contain dependency, build, and
getting-started information.

More sample patches are in my personal patch repo:

https://github.com/bgribble/mfp-patches

Where's it going?

I've been working on MFP as a spare time project for almost 14
years now. The likelihood that it will ever have more than a few
users is low. Luckily, that doesn't bother me much; MFP is a
tool I am building mainly for my own use and education.

That being said, if there's something about it that appeals to
you, I welcome your interest and participation.

Thanks,
Bill Gribble grib@billgribble.com

Fix version number in setup.py

Oops, I forgot to bump the version number in setup.py! This causes builds to fail.

Last release before Dear ImGUI branch

This release contains a lot of changes and fixes; see the file doc/ANNOUNCE-0.07 for details.

v0.7 will be the last release before work begins on the Dear ImGUI port. I don't plan to work on the Clutter backend any more than I have to, but it will still be available at least through the next release.

Release candidate 2 for v0.7

Fixes bugs in LV2 save/load handling, include paths on build, and more.