Looks familiar? I modelled it after the existing sample recording dialog in Renoise B)
What you see in the middle are current phrases in the instrument:

Green = Not selectedYellow = SelectedRed = The “virtual” phrase (where the next recording will appear)

Main features

Record notes from MIDI/PC keyboard at any LPB (lines-per-beat) value

Recordings are stored as phrases in the instrument

Bypass edit mode: your keyboard noodlings can be recorded even when playback is paused

Many recording options, ability to split recordings into “takes”, etc.

MIDI assignable interface

Keyboard shortcuts (when the dialog is focused)

[Left/Right] Push the arrow keys to select the current phrase
[Delete] Remove the current phrase from the instrument
[Enter] When not recording: prepare for input (“record-arm”). While recording: finalize recording (“stop”)
[Esc]While recording: cancel recording, else toggle edit mode
[Tab]Will take you back and forth between the phrase editor and your “current working space”
(it will try to memorize whatever middle frame you have currently selected, and restore that)

The tool’s stop button locks up and I can’t record anything without restarting renoise.

Ouch. Well, whenever a tool locks up you can still restart that particular tool without restarting Renoise. The tool browser has a “disable/enable” tool button that you can use. Should be a bit less painful

possible feature request to remedy this: could virtual phrases be split in multiple 512 line chunks, so that we can record indefinitely? (at least for however many notes are on the keyboard ofc)

Even better - a split option that we could control while recording, creating phrases on the fly?

Because, splitting automatically could be quite hard to manage (creating a bunch of recordings with 512 lines?).

Edit: all of the ideas below have been implemented since v0.9

Instead, I have been thinking about how it could be an option, much like the existing options:

* Manual split (hit some button/shortcut)

* Automatically split after #number_of_lines

* Automatically split when reaching end of pattern

Last option is perhaps especially interesting, as it would allow you to accompany your song and have each phrase aligned to each pattern’s beginning.

I should add too, that currently the tool is able to sync to the beginning and end of a pattern. It does however rely on idle notifiers, polling the playback progress ~10 times per second. And sometimes, it overshoots a little, depending on the song tempo and several other factors.

However, this is relatively easy to fix but simply something I have not yet gotten around to (on the TODO list).

I’ve never managed to work out how to get a tool to record notes played on qwerty keyboard with all the timings intact so will definitely be hacking this.

Also bonus points for a tool that doesn’t require duplex, qwerty keyboard is all the controller I need

Well, you should be aware that the PC keyboard input in this tool is in fact a huge hackaround. Currently, we can’t detect released keys, so what I’m doing is to listen for a pressed key and then “mimic” a pressed key by extending it’s life for as long as the tool is receiving a stream of repeated keys. This is good enough for note-on events, but not exactly precise for note offs. Furthermore, when you are pressing multiple keys, the first released one will release the other ones as well (because the stream of repeated keys temporarily pauses). So, if (note-off) timing really is essential you still need to get a MIDI controller of some kind.

Speaking of Duplex, working on the Keyboard application was actually what inspired me to make this. But yes, I thought it would be useful in other ways too so I decided to make it a standalone tool to begin with. And of course, once we’ve gotten rid of the worst bugs other tool authors are more than welcome to integrate Noodletrap into their own creations as well

I have gotten rid of the reported bugs, but want to do some feature finetuning before releasing.

First and foremost, it would be great if - when recording synced to beginning / end of pattern, that the resulting phrase would have this exact length.
Right now, it just looks at the recording’s length, which doesn’t work that well with phrases that are supposed to be looped.
Instead, I want to be so that recording in a 48 lines pattern, looping it a couple of times and proceeding into another one with 128 lines would result in a total of (48+48+128) 224 lines.

Also, I think it would be a good thing if a recording with a stop-timer (after X number of beats) would actually “pad” the recording to the recorded length in beats.
So, if you recorded for almost 16 beats and then let it time out, the resulting length could be “padded” to exactly 16 beats. Currently, it’s just using the recording’s length, which could be something like 15.62 beats.

+ MIDI Assignable record buttons
+ When using timed recording mode "stop after note --> beats" + "start atfirst incoming note", automatically prepare for new recording after having finished one.
FIXME When basing the recording’s length of an existing phrase, the result would become one line longer
FIXME When another instrument is loaded on top of (replacing) the working instrument, selecting a phrase could throw an error

MIDI assignable buttons should be pretty self-explanatory, but it’s worth pointing out that noodletrap expects a “trigger” (not a toggle) mapping. You can use toggling buttons, but you might need to press twice…to make use of them, first press CTRL/CMD+M to bring up the MIDI mapping dialog

The second feature is nothing but a little tweak to the existing functionality…

Yesterday, I was recording a set of standalone chords using the “start recording when first note arrives” (so notes are at the very start of the phrase), and with an automatic timeout (the “stop after note --> beats” option).

But I found it a bit annoying having to constantly prepare for a new recording (it means having to remove your hand from the keyboard!!), so I made the combination of these two start/stop options a special case that will automatically prepare for a new recording after each take.