Loopy Pro: Create music, your way.
What is Loopy Pro? — Loopy Pro is a powerful, flexible, and intuitive live looper, sampler, clip launcher and DAW for iPhone and iPad. At its core, it allows you to record and layer sounds in real-time to create complex musical arrangements. But it doesn’t stop there—Loopy Pro offers advanced tools to customize your workflow, build dynamic performance setups, and create a seamless connection between instruments, effects, and external gear.
Use it for live looping, sequencing, arranging, mixing, and much more. Whether you're a live performer, a producer, or just experimenting with sound, Loopy Pro helps you take control of your creative process.
Download on the App StoreLoopy Pro is your all-in-one musical toolkit. Try it for free today.
Audulus Office Hours Livestreams
Livestreaming Audulus Coding!
I'm livestreaming every morning* while working on the two libraries of code I'm writing for the Canvas and DSP nodes.
The Canvas node draws things and the DSP node processes and creates audio and control signals.
You can take the code that I'm writing and drop it into your editor window and then have access to a lot of really useful functions.
I'll post the VODs here once they're uploaded to YouTube
* - My morning in Croatia - check my Twitch schedule if you want to be there live
https://www.twitch.tv/markalanboyd/schedule
Library repos
https://github.com/markalanboyd/Audulus-Canvas
https://github.com/markalanboyd/Audulus-DSP
Livestream - Osc Class and High Low Detector
Livestream - LineGroup Polyline and Grid Methods
Comments
Just watching on Twitch because YouTube video at the moment are in 360p only.
It’s great you started this session. I'm looking forward to the future ones, and I’ll try to be there on time. After all, we are in the same time zone, haha. Fantastic! 🤩
Hey thanks! I saw you followed, much appreciated
In the future I'll transfer them as private then make them public when the encoding is finished - didn't realize that it would make it public immediately when 360p was available.
Would love to have you and anyone else stop by! No need to stay for the whole thing, people can just pop in and out and ask questions. I can always pause what I'm doing and explain something as well, so if you're reading this and you think "I don't know anything about programming, but I want to," I could also just teach you as I'm building things as you ask questions I'll explain what's going on in more detail.
Since no one was here while I was doing these ones, I was largely just muttering to myself, but I promise I can talk more intelligently and clearly about what's happening if I'm responding directly to people's questions.
No worries, your voice is relaxing, and I like the sound of the mechanical keyboard
. A concise explanation of everything you are doing is top-notch.
Btw, while listening to you, I’m transferring all my documents and notes from the last thirty years into the Obsidian vault, so I need someone in the background to share similar suffering with me, haha! 😂
Aw thanks! I’m speaking quietly because my wife and daughter are still sleeping at that hour haha.
It sounds like we’re both climbing up that hill - I don’t expect to get to 1.0 with this for at least a year - I have so much I want to add to it, and I haven’t even begun to do the 3d stuff. 30 years of notes!
I wish I’d been taking more notes in my life. I have to go look up old emails to remember what years I was in college for my resume haha.
Livestream - Variable Grid Lines and Explaining the Layer System
In this stream, starting at 5:00, Mark adds functionality to the LineGroup Grid method so you can separately define the number of horizontal and vertical lines. At 47:07 he explains how the layer system will work with nested layers and objects (that can have their own layers!).
0:00 - Moving the keyboard and mouse
2:20 - Exploring the new streaming window setup
5:00 - Adding variable number of vertical and horizontal lines to grid
28:50 - Thinking about what to do tomorrow
47:07 - Explaining the layer system
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
Livestream - Creating the Background Class
In this stream, Mark creates a Background class that allows you to reskin your modules. He also extends the Origin class to derive the corners of the Canvas node as attributes that can be used by the Background class to accurately paint the module regardless of where the Origin is set to.
0:00 - Writing todo notes
8:00 - Beginning Background class
39:20 - Deriving the corners of the module based on the Origin
1:16:00 - Working again on Background class
1:37:00 - Success! Then more tweaking
1:53:40 - Finished product
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
I managed to start “stream” this morning at 9:00 a.m., we are getting closer! 😂
You are a lucky person, my notes are nothing to be proud of. I have done them all of my life to make things quicker and easier to remember, but in reality, they are the complete opposite. 🫣 Judging by your streams, GPT is more efficient anyway.
Might have to be VOD for me as that’s a little too early in the day for me!
But thanks for putting these together.
GPT is amazing - there are a lot of naysayers, and it's not great for everything, but for asking highly googleable questions that I'm always forgetting, like "how to do a for loop in x language", it's awesome.
It's also great for doing repetitive tasks like "look at the pattern I'm doing here and continue it for the rest of them".
No problem, I understand! I'd do it later, but this is just what my schedule allows. I can be certain that if I wake up early enough every day that I at least have a couple uninterrupted hours to myself to code, and it's great to start the day with fun projects like these.
Livestream - Background as Singleton and Origin Refactor
In this livestream, Mark turns the Background class into a singleton, which prevents more than one instance of it being created in the same Canvas node. He then adds options for sharp or rounded corners, and does some refactoring on the Origin class (also turning it into a singleton). He ends the stream by adding z-indicies to all drawable classes, a discussion on caching in the Vec2 class (and why it's not done), and a future no-code website project to create code for the Canvas node without any programming at all.
0:00 Setup
1:00 Making Background class a singleton
12:30 Adding option for square or rounded corners
42:40 Refactoring Origin class (no required arguments, make into a singleton)
1:15:55 Add z-indicies to drawable objects
1:31:10 Vec2 caching discussion
1:43:00 Discussion of future no-code website that will help design modules
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
It’s about how you're using it. I noticed how my English writing significantly deteriorated because of grammar correction usage. So, I’m in a way forced to sign up for English lessons again. 🫠
In programming, I will never ask GPT for the solution, only for the list of options. Like an advanced reference library search. Otherwise, my thinking process will become spoiled and blunt. It’s really disturbing how easily you can make your brain lazy.
Livestream - Tree Class and DFS Algorithm
In this livestream, Mark implements a tree datastructure and a depth-first search (DFS) algorithm for returning a list of nodes from the tree. This Tree class will become the basis for the Layer class, which will essentially wrap the Tree class and add some useful methods to it.
0:00 monkeytype warmup
1:00 Deciding what to do
3:12 Explaining the tree data structure
13:30 Tree.new() - class constructor
30:04 Tree:add_child() - add a node to the tree
39:30 Tree.__tostring() - pretty print the tree for debugging purposes
1:05:30 Tree:remove_child() - remove a node from the tree
1:23:00 Discussing the layer system and why a tree is necessary
1:30:26 Tree:dfs() - return an array of all of the nodes in the tree in depth-first search order
2:03:43 Set class - implementing a Set class from scratch
2:30:30 Tree:dfs() - finish implement DFS
2:44:07 Success! Tree class finished
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
Livestream - DFS Pre and Post, BFS, and Pretty Print Tree
The first part of this stream was cut off due to technical difficulties. Before getting that sorted out, Mark had implemented a way to declare a tree structure as a nested table and then assign that structure to a root node. He also implemented a way to add children direction by declaring the Tree.__call() metamethod. This means you can now add children by doing node(child1, child2, ...).
In the rest of the stream, Mark fixes the depth-first search (DFS) algorithm from the day before and creates a pre and post version of it as well as a breadth-first search (BFS) algorithm. He then spends the rest of the stream figuring out how to pretty print the tree in the debug console in Audulus and creates an example patch to show how the tree keeps objects organized.
0:00 - Explaining Tree:add_structure()
3:09 - Discussing DFS pre, post and BFS algorithms
8:30 - Tree:dfs_pre() and Tree:dfs_post()
50:40 - Tree:bfs()
1:31:13 - Pretty print whole tree from root node
2:47:46 - Creating an example to illustrate tree's structure
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
Livestream - Planning the Layer System
In this shorter stream, Mark plans what to do with the layer system. The ultimate goal is to create a flat table from the tree ordered by z-index.
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
Livestream - Layer.new() Constructor
In this livestream, Mark continues to plan the structure of the Layer system and begins executing the solution. He creates the constructor and implements inheritance from the Tree class so that the Layer system can employ the data structure to keep itself organized.
0:00 - Discussing how to order layers by z-index
15:15 - Layer.new() constructor
38:57 - Implementing inheritance from Tree to Layer
56:40 - Sorting sublayers
1:01:35 - Planning for next stream
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
Livestream - Layer System Implemented
In this livestream, Mark successfully implements the Layer system. Users can now add objects to layers and programmatically change the z index of each layer to change the drawing order of objects on the fly.
0:00 - Explaning the Layer.new() constructor
1:52 - Refactor Layer.__tostring()
7:15 - Layer:sort_children()
21:09 - Refactor Layer:add_structure()
33:50 - Layer:dfs_sort()
48:14 - Layer:_dfs_collect()
1:07:37 - Testing layer system in Audulus
1:25:55 - Layer:draw() and refactor dfs_sort() to dfs_sort_and_collect()
1:52:42 - Debugging
2:12:20 - Layer:draw() adding ability to pass single object or table to layer contents
2:18:52 - Add aliases to tree_structure values for streamlined layer creation
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
Livestream - Refactor Layer Class
In this livestream, Mark fixes sorting of layer contents to include the object-level z-index. He then decides to skip inheriting from Tree and just refactors the Layer class to include a tree data structure internally. Finally, he implements a way to name layers and more cleanly add the layer tree to the root, as well as adjusting the shell script to automatically add the layer tree structure with a Background instance ready to go.
0:00 - Reviewing work from day before and deciding what to do
2:58 - Refactor Layer:draw() to limit nesting
13:34 - Refactor Layer:_dfs_sort_and_collect() to sort objects by z-index
22:14 - Redrawing Audulus circle example
27:00 - Debugging z_index sort
37:25 - Refactoring to not inherit from Tree
1:04:42 - Add Layer.name property for nicer printing
1:13:14 - Add Background instance
1:34:45 - Refactor Layer:__tostring() to print Layer.names
1:42:50 - Refactor Layer:__call()
1:52:34 - Debugging Layer:_call() to make it work with one layer
2:06:18 - Editing build_library.sh to build with better scaffolding code
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
Livestream - Layer Opacity and the Overlay Class
In this livestream, Mark adds the ability to define Layer opacity, which has a multiplicative effect for sublayers' and objects' opacity. He also refactors the Layer.__tostring() method to print the names of the objects in the layer contents. Then he reenvisions the Background class as an Overlay class which can be used to tint the layers below it.
0:00 - Explaining previous days' work
3:15 - Showing off Boot.dev maze solver project
5:23 - Deciding what to do
6:48 - Refactor Layer.new() to take optional arguments and Layer:add_tree() to take pass layer opacity property
17:25 - Implementing opacity property on the Color class and the Layer:draw() method
1:20:10 - Adding recursive multiplicative opacity for nested layers
1:44:50 - Refactor Debug.Logger() to correctly print layer tree
1:54:54 - Placing origin on Foreground layer in tree
2:00:00 - Refactor Layer.__tostring() to print object names in layer contents
2:18:10 - Refactor Background layer as Overlay class in order to use it as foreground as well
2:30:19 - Creating opacity and Overlay class demo
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/
Livestream - Layer Hue and Saturation
In this livestream, Mark adds the ability to define hue and saturation at the layer level, propogating downwards through the tree. He also fixes layer opacity.
0:00 - Going over work from yesterday
3:37 - Refactoring all drawable classes to do opacity correctly as well as cleaning up their constructors generally
1:12:54 - Add Layer.hue
2:11:33 - Fixing Layer.opacity
2:36:257 - Add Layer.saturation
2:41:08 - Try (and fail) to add Layer.lightness, deciding to save that for tomorrow
Connect with Mark on LinkedIn
https://www.linkedin.com/in/mark-boyd-dev/
Star the repos on Github! (check dev branch for latest changes)
https://github.com/markalanboyd/Audulus-DSP
https://github.com/markalanboyd/Audulus-Canvas
https://audulus.com/