sliderule posted:

The QY70 only has a single MIDI In/Out, so it's a bit less flexible. Also I really don't need the on-board sound, the on-board styles / accompaniment, the mini keyboard, or the portability. So it's a less than ideal option.

Oldstench posted:

Regarding Expert Sleepers Silent Way, I made a skin file for the StepLFO that has the following features:

• Euclidean rhythm generation
  
• Shift Pattern Left/Right
  
• Invert/Reverse Pattern
  
• Clear Pattern
  
• Random Pattern
  
• Pseudo-variable step length function - 2x, 3x, and 4x buttons extend the length of the pattern but keep the ratio of step length equal to the original pattern so you can remove steps from the end to fake variable step length
  
• Pattern shuffle - ex: pattern 12345678 becomes 15263748
  

You can't create new knobs with the ES scripting language, so I had to use existing knobs to do double duty.
For the Euclidean generator:
The Length in Steps parameter on the main page determines the total length of the pattern, and the End Step parameter determines the number of hits in the pattern. Due to this, you can only use the pattern generator in Start/Length mode.

So, choose the length, choose the number of hits with the End param, go to the Utility group and hit Process. Magic! It currently creates steps at with a max output value. This can be scaled.

Also, I don't know if it's just because I'm a terrible programmer or because LUA sucks, but sometimes the resulting patterns are a bit glitchy especially if you keep hammering the function buttons.

Save this code in a file called gui_steplfo.lua and place it in a skin folder named whatever you want.
Windows ex: %appdata%\Expert Sleepers\Silent Way\Skins\EuclidLFO(or whatever you want to call it)\Contents\Resources

No idea where it should go on a Mac.

Choose the skin from the plugin options page.

code:

-- return the window size
getWindowSize = getWindowSize or function()
	return 907, 415
end

-- create and lay out all the controls
createUI = createUI or function()

	createUICommon()

	-- constants
	local kKnobSpace = 45
	local kKnobSpaceV = 70
	local kWaveformW = 433
	local kWaveformH = 151
	local kDropdownW = 72
	local kTextW = 40
	local kLabelSpaceV = 30
	local kRandomW = 433
	local kRandomH = 18
	
	local function knobGroup( LR, id, title )
		g = group( title )
		
		local x = 0
		local y = 0

		theKnobRenderer = smallKnobRenderer

		smallKnobAndTextField( g, "Speed " .. LR,		"Speed",			x, y )
		smallKnobAndTextField( g, "Beats " .. LR,		"Beats",			x, y+kKnobSpaceV )
		x = x + kKnobSpace

		labelledDropDown( g, "Speed Multiplier " .. LR, "Multiplier", x, y, kDropdownW )
		y = y + kLabelSpaceV
		labelledDropDown( g, "Speed Mode " .. LR, "Speed Mode", x, y, kDropdownW )
		y = y + kLabelSpaceV
		labelledDropDown( g, "Sync " .. LR, "Sync", x, y, kDropdownW )
		y = y + kLabelSpaceV
		labelledDropDown( g, "Beat Divisor " .. LR, "Divisor", x, y, kDropdownW )
		y = y + kTextFieldH + 4
		g:add( paramButton( "Triplet " .. LR, "Triplet", x, y, kDropdownW, kTextFieldH ) )
		
		x = x + kDropdownW + 10
		y = 0

		labelledDropDown( g, "Swing Type " .. LR, "Swing Type", x, y, kDropdownW )
		y = y + kLabelSpaceV
		labelledDropDown( g, "Interpolation " .. LR, "Interpolation", x, y, kDropdownW )
		y = y + kLabelSpaceV
		labelledDropDown( g, "Range Mode " .. LR, "Range", x, y, kDropdownW )
		y = y + kLabelSpaceV
		labelledDropDown( g, "Length Mode " .. LR, "Length Mode", x, y, kDropdownW )
		y = y + kLabelSpaceV

		x = x + kDropdownW + 10
		y = 0

		local x1 = x
		
		smallKnobAndTextField( g, "Swing " .. LR,			"Swing",	x, y )
		x = x + kKnobSpace
		smallKnobAndTextField( g, "Gate Length " .. LR,		"Gate",		x, y, kTextW )
		x = x + kKnobSpace
		smallKnobAndTextField( g, "Phase " .. LR,			"Phase",	x, y, kTextW )
		x = x + kKnobSpace
		smallKnobAndTextField( g, "Asymmetry " .. LR,		"Asym",		x, y, kTextW )
		x = x + kKnobSpace
		smallKnobAndTextField( g, "Smoothing " .. LR,		"Smooth",	x, y )
		x = x + kKnobSpace

		local x2 = x

		x = x1
		y = y + kKnobSpaceV

		smallKnobAndTextField( g, "Offset " .. LR,			"Offset",	x, y, kTextW )
		x = x + kKnobSpace
		smallKnobAndTextField( g, "Multiplier " .. LR,		"Scale",	x, y, kTextW )
		x = x + kKnobSpace
		smallKnobAndTextField( g, "Start Step " .. LR,			"Start",	x, y )
		x = x + kKnobSpace
		smallKnobAndTextField( g, "Length In Steps " .. LR,		"Length",	x, y )
		x = x + kKnobSpace
		smallKnobAndTextField( g, "End Step " .. LR,			"End",	x, y )
		x = x + kKnobSpace

		return g
	end

	local function makeResetGroup( LR, id, title )
		g = group( title )
		
		local x = 0
		local y = 0

		theKnobRenderer = smallKnobRenderer

		labelledDropDown( g, "Signal Input " .. LR, "Signal", x, y+1.5*kLabelSpaceV, kKnobSize )
		labelledDropDown( g, "Input Mode " .. LR, "Input Mode", x+kKnobSpace, y+1.5*kLabelSpaceV, kDropdownW )
		labelledDropDown( g, "Trigger Input " .. LR, "Trigger", x, y+0*kLabelSpaceV, kKnobSize )
		labelledDropDown( g, "Reset Input " .. LR, "Reset", x, y+3*kLabelSpaceV, kKnobSize )
		labelledDropDown( g, "Reset By Note " .. LR, "Reset Mode", x+kKnobSpace, y+3*kLabelSpaceV, kDropdownW )
		x = x + kKnobSpace + kDropdownW + 2*pad
		smallKnobAndTextField( g, "Reset Note Min " .. LR,		"Reset Min",		x, y + kKnobSpaceV, nil, "%.0f" )
		smallKnobAndTextField( g, "Trigger Note Min " .. LR,		"Trigger Min",		x, y, nil, "%.0f" )
		x = x + 1.5*kKnobSpace
		smallKnobAndTextField( g, "Reset Note Max " .. LR,		"Reset Max",		x, y + kKnobSpaceV, nil, "%.0f" )
		smallKnobAndTextField( g, "Trigger Note Max " .. LR,		"Trigger Max",		x, y, nil, "%.0f" )
		x = x + kKnobSpace

		return g
	end

	local function makeRandomGroup( LR, id, title )
		g = group( title )
		
		local x = 0
		local y = 0
		local y2 = y + kKnobSpaceV

		theKnobRenderer = smallKnobRenderer
		
		local kButtonH = 20

		labelledDropDown( g, "Random Mode " .. LR, "Mode", x, y, kDropdownW )
		y = y + 30
		g:add( paramButton( "Random Set Next " .. LR, "Set Next", x, y, kDropdownW, kButtonH ) )
		y = y + 30
		g:add( paramButton( "Random Enable " .. LR, "Enable", x, y, kDropdownW, kButtonH ) )
		y = 0
		x = x + kDropdownW + pad
		smallKnobAndTextField( g, "Register Length " .. LR,		"Length",		x, y2, kTextW )
		smallKnobAndTextField( g, "DAC Bits " .. LR,		"DAC Bits",		x, y, kTextW )
		x = x + 1.5*kKnobSpace
		smallKnobAndTextField( g, "Randomness " .. LR,		"Randomness",		x, y, kTextW )

		return g
	end

	local function makeUtilGroup( LR, id, title)
		g = group( title )
		
		local x = 0
		local y = 0
		--local y2 = y + kKnobSpaceV
		--theKnobRenderer = smallKnobRenderer
		
		local kButtonH = 20
		
		g:add( luaButton(function() randDist(LR) end, "Random", "Randomize Distribution " ..LR, "push", x, y, kDropdownW, kButtonH))
		y = y + 25
		g:add( luaButton(function() shiftR(LR) end, "Shift R", "Shift Right " ..LR, "push", x, y, kDropdownW, kButtonH))
		y = y + 25
		g:add( luaButton(function() shiftL(LR) end, "Shift L", "Shift Left " ..LR, "push", x, y, kDropdownW, kButtonH))
		x = x + kDropdownW + pad
		y = 0
		g:add( luaButton(function() procEuclid(LR) end, "Euclidean", "Create Euclidean Rhythm " ..LR, "push", x, y, kDropdownW, kButtonH))
		y = y + 25
		g:add( luaButton(function() reverse(LR) end, "Reverse", "Reverse Pattern " ..LR, "push", x, y, kDropdownW, kButtonH))
		y = y + 25
		g:add( luaButton(function() invert(LR) end, "Invert", "Invert Pattern " ..LR, "push", x, y, kDropdownW, kButtonH))
		x = x + kDropdownW + pad
		y = 0
		g:add( luaButton(function() quadruple(LR) end, "4x", "Quadruple Pattern Length " ..LR, "push", x, y, kDropdownW, kButtonH))
		y = y + 25
		g:add( luaButton(function() triple(LR) end, "3x", "Triple Pattern Length " ..LR, "push", x, y, kDropdownW, kButtonH))
		y = y + 25
		g:add( luaButton(function() double(LR) end, "2x", "Double Pattern Length " ..LR, "push", x, y, kDropdownW, kButtonH))
		x = x + kDropdownW + pad
		y = 0
		g:add( luaButton(function() clear(LR) end, "Clear All", "Clear Pattern " ..LR, "push", x, y, kDropdownW, kButtonH))
		y = y + 25
		g:add( luaButton(function() shuffle(LR) end, "Shuffle", "Shuffle Pattern " ..LR, "push", x, y, kDropdownW, kButtonH))
		return g
	end
		
	-- make groups and knobs
	--

	theKnobRenderer = smallKnobRenderer

	miscGroup = group( "OSC" )
	smallKnobAndTextField( miscGroup, "OSC Port Offset",	"Port",		0*kKnobSpace, 0 )
	miscGroup:setVisible( false )

	local mainGroup = {}
	mainGroup.L = knobGroup( "L", 0, "Left Channel" )
	mainGroup.R = knobGroup( "R", 1, "Right Channel" )
	
	local resetGroup = {}
	resetGroup.L = makeResetGroup( "L", 0, "Left Channel" )
	resetGroup.R = makeResetGroup( "R", 1, "Right Channel" )
	resetGroup.L:setVisible( false )
	resetGroup.R:setVisible( false )

	local randomGroup = {}
	randomGroup.L = makeRandomGroup( "L", 0, "Left Channel" )
	randomGroup.R = makeRandomGroup( "R", 1, "Right Channel" )
	randomGroup.L:setVisible( false )
	randomGroup.R:setVisible( false )

	local utilGroup = {}
	utilGroup.L = makeUtilGroup( "L", 0, "Left Channel" )
	utilGroup.R = makeUtilGroup( "R", 1, "Right Channel" )
	utilGroup.L:setVisible( false )
	utilGroup.R:setVisible( false )
	
	-- positions!

	local xbase = windowEdgePad
	local ybase = windowEdgePad
	local x = xbase
	local y = ybase
	
	mainGroup.R:setPosition( x, y, true )
	resetGroup.R:setPosition( x, y, true )
	randomGroup.R:setPosition( x, y, true )
	utilGroup.R:setPosition( x, y, true )
	x = x + mainGroup.R:width() + pad
	local stepEdX = x
	
	miscGroup:setPosition( x, y, true )
	x = x + miscGroup:width() + pad
	
	x = xbase
	y = y + mainGroup.R:height() + pad
	local randomRightY = y
	y = y + kRandomH + pad
	local ybase2 = y
	
	mainGroup.L:setPosition( x, y, true )
	resetGroup.L:setPosition( x, y, true )
	randomGroup.L:setPosition( x, y, true )
	utilGroup.L:setPosition( x, y, true )
	x = x + mainGroup.L:width() + pad
	
	y = y + mainGroup.L:height() + pad
	local randomLeftY = y

	-- add directly positioned objects
	--

	local stepEds = {}
	stepEds.R = stepEditor( 1, stepEdX, ybase, kWaveformW, kWaveformH )
	setStepEditorColours( stepEds.R )
	add( stepEds.R )
	stepEds.L = stepEditor( 0, stepEdX, ybase2, kWaveformW, kWaveformH )
	setStepEditorColours( stepEds.L )
	add( stepEds.L )
	
	local bigEdW = stepEdX+kWaveformW-xbase
	local bigEds = {}
	bigEds.R = stepEditor( 1, xbase, ybase, bigEdW, kWaveformH )
	setStepEditorColours( bigEds.R )
	add( bigEds.R )
	elementSetVisible( bigEds.R, false )
	bigEds.L = stepEditor( 0, xbase, ybase2, bigEdW, kWaveformH )
	setStepEditorColours( bigEds.L )
	add( bigEds.L )
	elementSetVisible( bigEds.L, false )

	local function buttonRow( LR, id, x, y )
		local x, y = x, y
		local kButtonW = 60
		add( luaButton( function() _button1( mainGroup[LR], resetGroup[LR], randomGroup[LR], utilGroup[LR], stepEds[LR], bigEds[LR] ) end, "Main", "Show main controls", "push", x, y, kButtonW, kRandomH ) )
		x = x + kButtonW + pad
		add( luaButton( function() _button2( mainGroup[LR], resetGroup[LR], randomGroup[LR], utilGroup[LR], stepEds[LR], bigEds[LR] ) end, "Inputs", "Show input/reset/trigger controls", "push", x, y, kButtonW, kRandomH ) )
		x = x + kButtonW + pad
		add( luaButton( function() _button3( mainGroup[LR], resetGroup[LR], randomGroup[LR], utilGroup[LR], stepEds[LR], bigEds[LR] ) end, "Random", "Show random random controls", "push", x, y, kButtonW, kRandomH ) )
		x = x + kButtonW + pad
		add( luaButton( function() _button4( mainGroup[LR], resetGroup[LR], randomGroup[LR], utilGroup[LR], stepEds[LR], bigEds[LR] ) end, "Utility", "Show utility processor", "push", x, y, kButtonW, kRandomH ) )
		x = x + kButtonW + pad
		add( luaButton( function() _button5( mainGroup[LR], resetGroup[LR], randomGroup[LR], utilGroup[LR], stepEds[LR], bigEds[LR] ) end, "Big", "Show big step editor", "push", x, y, kButtonW, kRandomH ) )
		x = x + kButtonW + pad
		local reg = randomRegister( id, stepEdX, y, kRandomW, kRandomH )
		setRandomRegisterColours( reg )
		add( reg )
	end
	
	buttonRow( "L", 0, xbase, randomLeftY )
	buttonRow( "R", 1, xbase, randomRightY )

end		-- of createUI()

_button1 = function( g, rg, rndg, utlg, s, b )
	g:setVisible( true )
	rg:setVisible( false )
	rndg:setVisible( false )
	utlg:setVisible( false )
	elementSetVisible( s, true )
	elementSetVisible( b, false )
	redrawLabels()
end

_button2 = function( g, rg, rndg, utlg, s, b )
	g:setVisible( false )
	rg:setVisible( true )
	rndg:setVisible( false )
	utlg:setVisible( false )
	elementSetVisible( s, true )
	elementSetVisible( b, false )
	redrawLabels()
end

_button3 = function( g, rg, rndg, utlg, s, b )
	g:setVisible( false )
	rg:setVisible( false )
	rndg:setVisible( true )
	utlg:setVisible( false )
	elementSetVisible( s, true )
	elementSetVisible( b, false )
	redrawLabels()
end

_button4 = function( g, rg, rndg, utlg, s, b )
	g:setVisible( false )
	rg:setVisible( false )
	rndg:setVisible( false )
	utlg:setVisible( true )
	elementSetVisible( s, true )
	elementSetVisible( b, false )
	redrawLabels()
end

_button5 = function( g, rg, rndg, utlg, s, b )
	g:setVisible( false )
	rg:setVisible( false )
	rndg:setVisible( false )
	utlg:setVisible( false )
	elementSetVisible( s, false )
	elementSetVisible( b, true )
	redrawLabels()
end

shiftL = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local s = LuaStack()
	for i = 1, length do
		s:push(getParameter("Step " ..i .." " ..LR))
	end
	for i = length - 1, 1, -1 do
		setParameter("Step " ..i .." " ..LR, s:pop(1))
	end
	setParameter("Step " ..length .." " ..LR, s:pop(1))
end

shiftR = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local s = LuaStack()
	for i = length, 1, -1 do
		s:push(getParameter("Step " ..i .." " ..LR))
	end
	for i = 2, length do
		setParameter("Step " ..i .." " ..LR, s:pop(1))
	end
	setParameter("Step 1 " ..LR, s:pop(1))
end

randDist = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local s = LuaStack()
	local count ={}
	local k, val
	for i = 1, length do
		s:push(getParameter("Step " ..i .." " ..LR))
		table.insert(count, i)
	end
	for i = 1, length do
		k = math.random(table.getn(count))
		setParameter("Step " ..i .." " ..LR, s[count[k]])
		table.remove(count, k)
	end
end

invert = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local range = getParameter("Range Mode " ..LR)
	local s = LuaStack()
	local k = 0
	for i = 1, length do
		s:push(getParameter("Step " ..i .." " ..LR))
	end
	if range == 1 then -- bipolar
		for i = length, 1, -1 do
			setParameter("Step " ..i .." " ..LR, (s:pop(1) * -1))
		end
	else -- unipolar
		for i = length, 1, -1 do
			k = 1 - s:pop(1)
			if k > 1 then
				setParameter("Step " ..i .." " ..LR, 1)
			elseif k < 0 then
				setParameter("Step " ..i .." " ..LR, 0)
			else
				setParameter("Step " ..i .." " ..LR, k)
			end
		end
	end
end

reverse = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local s = LuaStack()
	for i = 1, length do
		s:push(getParameter("Step " ..i .." " ..LR))
	end
	for i = 1, length do
		setParameter("Step " ..i .." " ..LR, s:pop(1))
	end
end

procEuclid = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local hits = getParameter("End Step " ..LR)
	euclidgen(length, hits, LR)
end

double = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local l2x = length * 2
	if l2x < 96 then
		local s = {}
		for i = 1, length do
			table.insert(s, getParameter("Step " ..i .." " ..LR))
		end
		setParameter("Length In Steps " ..LR, l2x)
		for i = 1, l2x do
			setParameter("Step " ..i .." " ..LR, s[math.ceil(i/2)])
		end
	end
end

triple = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local l3x = length * 3
	if l3x < 96 then
		local s = {}
		for i = 1, length do
			table.insert(s, getParameter("Step " ..i .." " ..LR))
		end
		setParameter("Length In Steps " ..LR, l3x)
		for i = 1, l3x do
			setParameter("Step " ..i .." " ..LR, s[math.ceil(i/3)])
		end
	end
end

quadruple = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local l4x = length * 4
	if l4x < 96 then
		local s = {}
		for i = 1, length do
			table.insert(s, getParameter("Step " ..i .." " ..LR))
		end
		setParameter("Length In Steps " ..LR, l4x)
		for i = 1, l4x do
			setParameter("Step " ..i .." " ..LR, s[math.ceil(i/4)])
		end
	end
end

clear = function(LR)
	for i = 1, 96 do
		setParameter("Step " ..i .." " ..LR, 0)
	end
end

shuffle = function(LR)
	local length = getParameter("Length In Steps " ..LR)
	local half = length / 2
	local back = LuaStack()
	local front = LuaStack()
	for i = length, length - math.floor(half) + 1, -1 do
		back:push(getParameter("Step " ..i .." " ..LR))
	end
	for i = length - math.floor(half), 1, -1 do
		front:push(getParameter("Step " ..i .." " ..LR))
	end
	for i = 1, length, 2 do
		setParameter("Step " ..i  .." " ..LR, front:pop(1))
	end
	for i = 2, length, 2 do
		setParameter("Step " ..i .." " ..LR, back:pop(1))
	end
end

-- based on algorithm from [url]http://www.hisschemoller.com/2011/euclidean-rhythms/[/url]
function euclidgen(len, hits, LR)
	local r = LuaStack()
	if hits >= len then
		for i = 1, len do
			setParameter("Step " ..i .." " ..LR, 1)
		end
	else
		local rests = len - hits
		if rests >= hits then
			local per_pulse = math.floor(rests/hits)
			local remainder = rests % hits
			for i = 0, hits - 1, 1 do
				r:push(1)
				for j = 0, per_pulse - 1, 1 do
					r:push(0)
				end
				if i < remainder then
					r:push(0)
				end
			end
		else
			local per_rest = math.floor((hits - rests) / rests)
			remainder = (hits - rests) % rests
			for i = 0, rests - 1, 1 do
				r:push(1)
				r:push(0)
				for j = 0, per_rest - 1, 1 do
					r:push(1)
				end
				if i < remainder then
					r:push(1)
				end
			end
		end
		--
		for i = len, 1, -1 do
			setParameter("Step " ..i .." " ..LR, r:pop(1))
		end
	end
end

-- taken from [url]http://snippets.luacode.org/snippets/stack_97[/url]
function LuaStack(t)
	local Stack = {
		push = function(self, ...)
			for _, v in ipairs{...} do
				self[#self+1] = v
			end
		end,
		pop = function(self, num)
			local num = num or 1
			if num > #self then
				error("stack underflow")
			end
			local ret = {}
			for i = num, 1, -1 do
				ret[#ret+1] = table.remove(self)
			end
			return unpack(ret)
		end
	}
	return setmetatable(t or {}, {__index = Stack})
end

WAFFLEHOUND posted:

It's not really synth related, but I like all of you and I sold a synth to buy it soooo...

sliderule posted:

QY700 is right out. There has been a WANTED:QY700 @ $400 ad on Kijiji since the beginning of March. The QY70 only has a single MIDI In/Out, so it's a bit less flexible. Also I really don't need the on-board sound, the on-board styles / accompaniment, the mini keyboard, or the portability. So it's a less than ideal option.

The MC80 fits the functionality bill, but the seller has gone AWOL on me, so I guess I have a little more time to search.

MrLonghair posted:

If you want a the most powerful modern hardware sequencers it's MPC500, MPC1000, MPC2500, and JJOS where applicable. The timing is as tight as it should be, just a bit unwieldy and better off for those of us who record live.

Startyde posted:

e- Almost forgot, there's also the MV30 which is, iirc, more directly built on the MC500 with a U220/D70 bolted on. They seem to be going for very cheap, never had one.

sliderule posted:

edit: Is that tiny screen going to be an obstacle for sequencing external tracks?

WAFFLEHOUND posted:

Reminder that a dirt cheapass computer is far more fun for drums and midi than a thousand dollar dedicated sequencer.

WAFFLEHOUND posted:

It's not really synth related, but I like all of you and I sold a synth to buy it soooo... after four and a half years of thinking about it and a bunch of time on waitlists I finally got a handpan. Super loving excited.

Also, selling off most of my hardware and buying a mixer was probably a really good idea, I'm actually sitting down and doing stuff. I can't believe how much routing everything through one set of ins has sped up my workflow.

WAFFLEHOUND posted:

Reminder that a dirt cheap computer is far more fun for drums and midi than a thousand dollar dedicated sequencer.

WAFFLEHOUND posted:

So does a hammer to hit yourself in the dick with, which is arguably more efficient than hardware sampler/sequencers since at least you're getting instant percussion.

WAFFLEHOUND posted:

It's not really synth related, but I like all of you and I sold a synth to buy it soooo... after four and a half years of thinking about it and a bunch of time on waitlists I finally got a handpan. Super loving excited.

Also, selling off most of my hardware and buying a mixer was probably a really good idea, I'm actually sitting down and doing stuff. I can't believe how much routing everything through one set of ins has sped up my workflow.

WAFFLEHOUND posted:

a hammer to hit yourself in the dick with is cheaper as well, which is arguably more efficient than hardware sampler/sequencers since at least you're getting instant percussion.

WAFFLEHOUND posted:

WAFFLEHOUND posted:

Reminder that a dirt cheap computer is far more fun for drums and midi than a thousand dollar dedicated sequencer.

Sizone posted:

Also a reminder both his beloved A4 and 303 are basically thousand dollar dedicated sequencers.

MrLonghair posted:

I think the Model D is the best synth ever, after on-hands experience

But then again, synths that use joysticks trigger psychotic murder rampages in me.

WAFFLEHOUND posted:

To be fair, the sequencer on the A4 is great, I just would want that as the main sequencer all around.

renderful posted:

That's why Audio Damage copied it and is releasing it for EuroRack with all of the A4 sequencer's features and more: http://www.analogindustries.com/b1873/The+New+poo poo/

Oldstench posted:

It looks like it, but the power of the Elektron sequencers is in the p-locks, and I don't see this having that feature unless I'm completely blind and missing a major bullet point.

WAFFLEHOUND posted:

That honestly sounds really cool. I think the only thing that could get me back into modular is something like a self-contained Polivoks rack where I don't have to buy it piece by piece. And it was priced like a box of donuts.