diff --git a/src/Album-Examples/AlbTextEditorExamples.class.st b/src/Album-Examples/AlbTextEditorExamples.class.st
index 35049f5..e03617c 100644
--- a/src/Album-Examples/AlbTextEditorExamples.class.st
+++ b/src/Album-Examples/AlbTextEditorExamples.class.st
@@ -180,6 +180,39 @@ AlbTextEditorExamples class >> exampleMethodTextOpenEmbedElement [
 	space show
 ]
 
+{ #category : #examples }
+AlbTextEditorExamples class >> exampleMultiCursorEditing [
+	"Open an editor with a cursor at the start of every line: type to edit all lines at once.
+	Alt-click (Option-click on macOS) toggles a cursor,
+	Ctrl+Alt+Up/Down (Cmd+Option+Up/Down on macOS) adds a cursor above/below,
+	Escape keeps only the primary cursor"
+
+	<script>
+
+	| space editorElement editor text lineStarts |
+	text := String cr join: #(
+		'red := Color red.'
+		'green := Color green.'
+		'blue := Color blue.'
+		'yellow := Color yellow.' ).
+	editorElement := self newElement.
+	editorElement text: text asRopedText.
+	editorElement editor text attributes: { (BlFontSizeAttribute size: 18) }.
+	editor := editorElement editor.
+	lineStarts := OrderedCollection with: 0.
+	text withIndexDo: [ :each :index | each = Character cr ifTrue: [ lineStarts add: index ] ].
+	editor navigator
+		moveTo: lineStarts first;
+		apply.
+	lineStarts allButFirst do: [ :each | editor addCursorAt: each ].
+	space := BlSpace new.
+	space title: 'Album multi-cursor: Option/Alt-click, Cmd/Ctrl+Option+Up/Down, Esc'.
+	space extent: 700 @ 300.
+	space root addChild: editorElement.
+	space show.
+	editorElement infinite requestFocus
+]
+
 { #category : #examples }
 AlbTextEditorExamples class >> exampleTextOpen [
 	<script>
diff --git a/src/Album-Tests/AlbMultiCursorTest.class.st b/src/Album-Tests/AlbMultiCursorTest.class.st
new file mode 100644
index 0000000..fb8b68c
--- /dev/null
+++ b/src/Album-Tests/AlbMultiCursorTest.class.st
@@ -0,0 +1,749 @@
+"
+I test multi-cursor editing in Album.
+
+Editor states are written in a compact notation: the text with a | at every cursor position.
+For example 'a|b|c' is the text abc with cursors at positions 1 and 2.
+#editorFrom: builds an editor from such a spec (the first | is the primary cursor), #specOf: renders an editor back.
+"
+Class {
+	#name : #AlbMultiCursorTest,
+	#superclass : #BlSpaceTestCase,
+	#category : #'Album-Tests-Operators'
+}
+
+{ #category : #helpers }
+AlbMultiCursorTest >> backspaceOracle: aSpec [
+	"The expected spec after deleting the character before every cursor: remove the character preceding each |, then merge cursors that meet"
+
+	| result |
+	result := OrderedCollection new.
+	aSpec do: [ :each |
+		each = $|
+			ifTrue: [
+				(result notEmpty and: [ result last ~= $| ]) ifTrue: [ result removeLast ].
+				(result notEmpty and: [ result last = $| ]) ifFalse: [ result add: $| ] ]
+			ifFalse: [ result add: each ] ].
+	^ String withAll: result
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> cursorElementsIn: anEditorElement [
+
+	| found |
+	space settle.
+	found := OrderedCollection new.
+	anEditorElement allChildrenBreadthFirstDo: [ :each |
+		(each isKindOf: AlbCursorElement) ifTrue: [ found add: each ] ].
+	^ found
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> editorFrom: aSpec [
+	"Return a text editor on the text of aSpec with a cursor at every | position. The first one is the primary cursor"
+
+	| positions text editor navigator |
+	positions := OrderedCollection new.
+	text := String streamContents: [ :out |
+		aSpec do: [ :each |
+			each = $|
+				ifTrue: [ positions add: out position ]
+				ifFalse: [ out nextPut: each ] ] ].
+	editor := AlbTextEditor new.
+	editor text: text asRopedText.
+	navigator := editor navigator.
+	navigator moveTo: positions first.
+	positions allButFirst do: [ :each | navigator addCursorAt: each ].
+	navigator apply.
+	^ editor
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> elementFrom: aSpec [
+	"Return an editor element shown in the test space, for operations that need the rendered text"
+
+	| anElement |
+	anElement := AlbEditorElement new.
+	anElement constraintsDo: [ :c |
+		c horizontal exact: 400.
+		c vertical exact: 300 ].
+	anElement text: (self editorFrom: aSpec) text.
+	space deferAndSettle: [ space root addChild: anElement ].
+	space deferAndSettle: [ self setCursorsOf: anElement editor from: aSpec ].
+	^ anElement
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> lines: aCollectionOfStrings [
+
+	^ String cr join: aCollectionOfStrings
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> preservingClipboardDo: aBlock [
+	"Evaluate aBlock and restore the system clipboard afterwards, so that tests do not overwrite it"
+
+	| aSavedText |
+	aSavedText := Clipboard clipboardText asString.
+	aBlock ensure: [ Clipboard clipboardText: aSavedText ]
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> randomSpecUsing: aRandom [
+	"Return a random spec of up to 12 characters with at least one cursor"
+
+	| text positions |
+	text := String new: (aRandom nextInteger: 13) - 1.
+	1 to: text size do: [ :i | text at: i put: ('ab c' at: (aRandom nextInteger: 4)) ].
+	positions := (0 to: text size) select: [ :each | aRandom next < 0.3 ].
+	positions ifEmpty: [ positions := { (aRandom nextInteger: text size + 1) - 1 } ].
+	^ String streamContents: [ :out |
+		0 to: text size do: [ :i |
+			(positions includes: i) ifTrue: [ out nextPut: $| ].
+			i < text size ifTrue: [ out nextPut: (text at: i + 1) ] ] ]
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> selectionOf: anEditor [
+	"Return the selected intervals as from -> to associations"
+
+	| theBounds |
+	theBounds := OrderedCollection new.
+	anEditor selection do: [ :each | theBounds add: each from -> each to ].
+	^ theBounds asArray
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> setCursorsOf: anEditor from: aSpec [
+
+	| positions index navigator |
+	positions := OrderedCollection new.
+	index := 0.
+	aSpec do: [ :each |
+		each = $|
+			ifTrue: [ positions add: index ]
+			ifFalse: [ index := index + 1 ] ].
+	navigator := anEditor navigator.
+	navigator moveTo: positions first.
+	positions allButFirst do: [ :each | navigator addCursorAt: each ].
+	navigator apply
+]
+
+{ #category : #helpers }
+AlbMultiCursorTest >> specOf: anEditor [
+	"Return the text of anEditor with a | at every cursor position"
+
+	| spec |
+	spec := anEditor text asString.
+	anEditor cursors reverseDo: [ :each |
+		spec := (spec first: each position) , '|' , (spec allButFirst: each position) ].
+	^ spec
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_add_cursor_at_existing_position_is_ignored [
+
+	| editor |
+	editor := self editorFrom: 'a|bc'.
+	editor addCursorAt: 1.
+	self assert: (self specOf: editor) equals: 'a|bc'.
+	self deny: editor hasMultipleCursors
+]
+
+{ #category : #'tests - shortcuts' }
+AlbMultiCursorTest >> test_add_cursor_below_and_above [
+
+	| element editor |
+	element := self elementFrom: (self lines: #( 'abc' 'd|ef' 'ghi' )).
+	editor := element editor.
+	space deferAndSettle: [ AlbEditorAddCursorBelowShortcut new performOnEditor: editor element: element dueTo: nil ].
+	space deferAndSettle: [ AlbEditorAddCursorAboveShortcut new performOnEditor: editor element: element dueTo: nil ].
+	self assert: (self specOf: editor) equals: (self lines: #( 'a|bc' 'd|ef' 'g|hi' ))
+]
+
+{ #category : #'tests - deleting' }
+AlbMultiCursorTest >> test_backspace_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'ab|cd|'.
+	editor deleter
+		oneBeforeCursor;
+		delete.
+	self assert: (self specOf: editor) equals: 'a|c|'
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_backspace_deletes_every_selection [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	editor deleter
+		selected;
+		oneBeforeCursorIfOutsideOfSelection;
+		delete.
+	self assert: (self specOf: editor) equals: '| | |'.
+	self assert: editor selection isEmpty
+]
+
+{ #category : #'tests - deleting' }
+AlbMultiCursorTest >> test_backspace_merges_cursors_that_meet [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c'.
+	editor deleter
+		oneBeforeCursor;
+		delete.
+	self assert: (self specOf: editor) equals: '|c'.
+	self deny: editor hasMultipleCursors
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_copy_selections_and_paste_them_one_per_cursor [
+
+	self preservingClipboardDo: [
+		| editor |
+		editor := self editorFrom: (self lines: #( '|one = 1' '|two = 2' '|three = 3' )).
+		editor selecter
+			extendToNextWordEnd;
+			select.
+		editor copySelected.
+		self assert: Clipboard clipboardText asString lines asArray equals: #( 'one' 'two' 'three' ).
+		editor deselecter
+			all;
+			deselect.
+		editor navigator
+			moveToLineEnd;
+			apply.
+		editor paste.
+		self assert: (self specOf: editor) equals: (self lines: #( 'one = 1one|' 'two = 2two|' 'three = 3three|' )) ]
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_cursors_are_sorted_and_primary_is_kept [
+
+	| editor |
+	editor := self editorFrom: 'ab|c|d'.
+	editor addCursorAt: 0.
+	self assert: (editor cursors collect: [ :each | each position ]) equals: #( 0 2 3 ).
+	self assert: editor cursor position equals: 2.
+	self assert: editor hasMultipleCursors
+]
+
+{ #category : #'tests - rendering' }
+AlbMultiCursorTest >> test_cursors_in_the_same_word_are_all_displayed [
+
+	| element positions |
+	element := self elementFrom: 'o|n|e two'.
+	positions := (self cursorElementsIn: element) collect: [ :each | each parent text asString -> each textPosition ].
+	self assert: positions asSet equals: { 'one' -> 1. 'one' -> 2 } asSet
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_cut_removes_every_selection [
+
+	self preservingClipboardDo: [
+		| editor |
+		editor := self editorFrom: '|one |two |three'.
+		editor selecter
+			extendToNextWordEnd;
+			select.
+		editor cutSelected.
+		self assert: (self specOf: editor) equals: '| | |'.
+		self assert: editor selection isEmpty.
+		self assert: Clipboard clipboardText asString lines asArray equals: #( 'one' 'two' 'three' ) ]
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_cut_single_selection_is_unchanged [
+
+	self preservingClipboardDo: [
+		| editor |
+		editor := self editorFrom: 'one |two three'.
+		editor selecter
+			extendToNextWordEnd;
+			select.
+		editor cutSelected.
+		self assert: (self specOf: editor) equals: 'one | three'.
+		self assert: Clipboard clipboardText asString equals: 'two' ]
+]
+
+{ #category : #'tests - shortcuts' }
+AlbMultiCursorTest >> test_escape_keeps_only_the_primary_cursor [
+
+	| element |
+	element := self elementFrom: 'a|b|c|'.
+	space deferAndSettle: [ AlbEditorDeselectAllShortcut new performOnEditor: element editor element: element dueTo: nil ].
+	self assert: (self specOf: element editor) equals: 'a|bc'
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_extend_selection_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		moveOneToRight;
+		select.
+	editor selecter
+		moveOneToRight;
+		select.
+	self assert: (self specOf: editor) equals: 'on|e tw|o th|ree'.
+	self assert: (self selectionOf: editor) equals: { 0 -> 2. 4 -> 6. 8 -> 10 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_extend_selection_down_at_every_cursor [
+
+	| element |
+	element := self elementFrom: (self lines: #( '|abc' 'def' '|ghi' 'jkl' )).
+	space deferAndSettle: [
+		element editor selecter
+			moveOneDown;
+			select ].
+	self assert: (self specOf: element editor) equals: (self lines: #( 'abc' '|def' 'ghi' '|jkl' )).
+	self assert: (self selectionOf: element editor) equals: { 0 -> 4. 8 -> 12 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_extend_selection_to_word_end_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	self assert: (self specOf: editor) equals: 'one| two| three|'.
+	self assert: (self selectionOf: editor) equals: { 0 -> 3. 4 -> 7. 8 -> 13 }
+]
+
+{ #category : #'tests - deleting' }
+AlbMultiCursorTest >> test_forward_delete_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: '|ab|cd'.
+	editor deleter
+		oneAfterCursor;
+		delete.
+	self assert: (self specOf: editor) equals: '|b|d'
+]
+
+{ #category : #'tests - deleting' }
+AlbMultiCursorTest >> test_forward_delete_merges_cursors_that_meet [
+
+	| editor |
+	editor := self editorFrom: '|a|bc'.
+	editor deleter
+		oneAfterCursor;
+		delete.
+	self assert: (self specOf: editor) equals: '|c'
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_insert_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c|'.
+	editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	self assert: (self specOf: editor) equals: 'aX|bX|cX|'
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_insert_at_start_and_end [
+
+	| editor |
+	editor := self editorFrom: '|abc|'.
+	editor inserter
+		atCursor;
+		string: '#';
+		insert.
+	self assert: (self specOf: editor) equals: '#|abc#|'
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_insert_several_characters_at_adjacent_cursors [
+
+	| editor |
+	editor := self editorFrom: 'a|b|'.
+	editor inserter
+		atCursor;
+		string: 'xyz';
+		insert.
+	self assert: (self specOf: editor) equals: 'axyz|bxyz|'
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_last_cursor_is_never_removed [
+
+	| editor |
+	editor := self editorFrom: 'a|bc'.
+	editor navigator
+		removeCursorAt: 1;
+		apply.
+	self assert: (self specOf: editor) equals: 'a|bc'
+]
+
+{ #category : #'tests - inserting' }
+AlbMultiCursorTest >> test_line_ending_keeps_the_indentation_of_each_cursor_line [
+
+	| editor |
+	editor := self editorFrom: (self lines: { String tab , 'a|'. 'b|' }).
+	editor inserter
+		atCursor;
+		crLineEndingWithWhitespace;
+		insert.
+	self assert: (self specOf: editor) equals: (self lines: { String tab , 'a'. String tab , '|'. 'b'. '|' })
+]
+
+{ #category : #'tests - rendering' }
+AlbMultiCursorTest >> test_merged_cursors_remove_their_elements [
+
+	| element |
+	element := self elementFrom: 'a|b|cd|'.
+	space deferAndSettle: [
+		element editor deleter
+			oneBeforeCursor;
+			delete ].
+	self assert: (self specOf: element editor) equals: '|c|'.
+	self assert: (self cursorElementsIn: element) size equals: 2
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_moveTo_keeps_a_single_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c|'.
+	editor navigator
+		moveTo: 0;
+		apply.
+	self assert: (self specOf: editor) equals: '|abc'
+]
+
+{ #category : #'tests - navigating' }
+AlbMultiCursorTest >> test_move_down_moves_every_cursor [
+
+	| element |
+	element := self elementFrom: (self lines: #( 'a|bc|' 'def' 'ghi' )).
+	space deferAndSettle: [
+		element editor navigator
+			moveDown;
+			apply ].
+	self assert: (self specOf: element editor) equals: (self lines: #( 'abc' 'd|ef|' 'ghi' ))
+]
+
+{ #category : #'tests - navigating' }
+AlbMultiCursorTest >> test_move_left_and_right_move_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|bc|d'.
+	editor navigator
+		moveRight;
+		apply.
+	self assert: (self specOf: editor) equals: 'ab|cd|'.
+	editor navigator
+		moveLeft;
+		apply.
+	editor navigator
+		moveLeft;
+		apply.
+	self assert: (self specOf: editor) equals: '|ab|cd'
+]
+
+{ #category : #'tests - navigating' }
+AlbMultiCursorTest >> test_move_left_merges_cursors_at_text_start [
+
+	| editor |
+	editor := self editorFrom: '|a|b'.
+	editor navigator
+		moveLeft;
+		apply.
+	self assert: (self specOf: editor) equals: '|ab'
+]
+
+{ #category : #'tests - navigating' }
+AlbMultiCursorTest >> test_move_to_line_start_and_end_per_cursor [
+
+	| editor |
+	editor := self editorFrom: (self lines: #( 'ab|c' 'd|ef' )).
+	editor navigator
+		moveToLineEnd;
+		apply.
+	self assert: (self specOf: editor) equals: (self lines: #( 'abc|' 'def|' )).
+	editor navigator
+		moveToLineStart;
+		apply.
+	self assert: (self specOf: editor) equals: (self lines: #( '|abc' '|def' ))
+]
+
+{ #category : #'tests - rendering' }
+AlbMultiCursorTest >> test_one_cursor_element_per_cursor [
+
+	| element cursorElements |
+	element := self elementFrom: (self lines: #( 'o|ne t|wo' 'thr|ee' )).
+	cursorElements := self cursorElementsIn: element.
+	self assert: cursorElements size equals: 3.
+	self assert: (cursorElements select: [ :each | each == element cursorElement ]) size equals: 1
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|'.
+	editor paster
+		text: '--';
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: 'a--|b--|'
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_ignores_a_trailing_line_ending [
+
+	| editor |
+	editor := self editorFrom: 'a|b|'.
+	editor paster
+		text: (self lines: #( 'X' 'Y' '' ));
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: 'aX|bY|'
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_multiple_lines_with_a_single_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b'.
+	editor paster
+		text: (self lines: #( 'X' 'Y' ));
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: (self lines: #( 'aX' 'Y|b' ))
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_one_line_per_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c|'.
+	editor paster
+		text: (self lines: #( 'X' 'Y' 'Z' ));
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: 'aX|bY|cZ|'
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_paste_whole_text_when_line_count_differs [
+
+	| editor |
+	editor := self editorFrom: 'a|b|'.
+	editor paster
+		text: (self lines: #( 'X' 'Y' 'Z' ));
+		atCursor;
+		paste.
+	self assert: (self specOf: editor) equals: (self lines: #( 'aX' 'Y' 'Z|bX' 'Y' 'Z|' ))
+]
+
+{ #category : #'tests - oracle' }
+AlbMultiCursorTest >> test_random_backspaces_match_oracle [
+
+	| random |
+	random := Random seed: 7.
+	200 timesRepeat: [
+		| spec editor |
+		spec := self randomSpecUsing: random.
+		editor := self editorFrom: spec.
+		editor deleter
+			oneBeforeCursor;
+			delete.
+		self assert: (self specOf: editor) equals: (self backspaceOracle: spec) ]
+]
+
+{ #category : #'tests - oracle' }
+AlbMultiCursorTest >> test_random_insertions_match_oracle [
+
+	| random |
+	random := Random seed: 42.
+	200 timesRepeat: [
+		| spec editor |
+		spec := self randomSpecUsing: random.
+		editor := self editorFrom: spec.
+		editor inserter
+			atCursor;
+			string: 'xy';
+			insert.
+		self
+			assert: (self specOf: editor)
+			equals: (spec copyReplaceAll: '|' with: 'xy|') ]
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_removeSecondaryCursors [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c|'.
+	editor removeSecondaryCursors.
+	self assert: (self specOf: editor) equals: 'a|bc'
+]
+
+{ #category : #'tests - cursors' }
+AlbMultiCursorTest >> test_remove_primary_cursor_promotes_a_secondary_one [
+
+	| editor |
+	editor := self editorFrom: '|ab|c'.
+	editor navigator
+		removeCursorAt: 0;
+		apply.
+	self assert: (self specOf: editor) equals: 'ab|c'.
+	self assert: editor cursor position equals: 2
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_select_all_keeps_a_single_cursor [
+	"An explicit range replaces the cursors, as in VS Code"
+
+	| editor |
+	editor := self editorFrom: 'a|b|c'.
+	editor selecter
+		all;
+		select.
+	self assert: (self specOf: editor) equals: 'abc|'.
+	self assert: (self selectionOf: editor) equals: { 0 -> 3 }
+]
+
+{ #category : #'tests - copy/paste' }
+AlbMultiCursorTest >> test_selected_texts_one_per_selection [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	self assert: editor selectedTexts equals: #( 'one' 'two' 'three' )
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_selections_that_meet_merge_their_cursors [
+	"The cursor kept is the one at the edge of the merged selection; it becomes primary"
+
+	| editor |
+	editor := self editorFrom: 'a|bc|def'.
+	editor selecter
+		moveOneToRight;
+		select.
+	editor selecter
+		moveOneToRight;
+		select.
+	self assert: (self specOf: editor) equals: 'abcde|f'.
+	self assert: (self selectionOf: editor) equals: { 1 -> 5 }.
+	self deny: editor hasMultipleCursors.
+	editor selecter
+		moveOneToLeft;
+		select.
+	self assert: (self selectionOf: editor) equals: { 1 -> 4 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_shrink_selection_at_every_cursor [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		moveOneToRight;
+		select.
+	editor selecter
+		moveOneToRight;
+		select.
+	editor selecter
+		moveOneToLeft;
+		select.
+	self assert: (self specOf: editor) equals: 'o|ne t|wo t|hree'.
+	self assert: (self selectionOf: editor) equals: { 0 -> 1. 4 -> 5. 8 -> 9 }
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_typing_over_selections_keeps_one_cursor_element_per_cursor [
+
+	| element |
+	element := self elementFrom: '|one |two |three'.
+	space deferAndSettle: [
+		element editor selecter
+			extendToNextWordEnd;
+			select.
+		element editor inserter
+			atCursor;
+			string: 'X';
+			insert ].
+	self assert: (self specOf: element editor) equals: 'X| X| X|'.
+	self assert: (self cursorElementsIn: element) size equals: 3
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_typing_over_selections_undo_and_redo [
+	"As with a single cursor, replacing selected text is undone in two steps: the insertion, then the deletion"
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	editor undo.
+	self assert: (self specOf: editor) equals: '| | |'.
+	editor undo.
+	self assert: (self specOf: editor) equals: 'one| two| three|'.
+	editor redo.
+	editor redo.
+	self assert: (self specOf: editor) equals: 'X| X| X|'
+]
+
+{ #category : #'tests - selecting' }
+AlbMultiCursorTest >> test_typing_replaces_every_selection [
+
+	| editor |
+	editor := self editorFrom: '|one |two |three'.
+	editor selecter
+		extendToNextWordEnd;
+		select.
+	editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	self assert: (self specOf: editor) equals: 'X| X| X|'.
+	self assert: editor selection isEmpty
+]
+
+{ #category : #'tests - history' }
+AlbMultiCursorTest >> test_undo_and_redo_insertion_restore_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'a|b|c'.
+	editor inserter
+		atCursor;
+		string: 'X';
+		insert.
+	editor undo.
+	self assert: (self specOf: editor) equals: 'a|b|c'.
+	editor redo.
+	self assert: (self specOf: editor) equals: 'aX|bX|c'
+]
+
+{ #category : #'tests - history' }
+AlbMultiCursorTest >> test_undo_deletion_restores_every_cursor [
+
+	| editor |
+	editor := self editorFrom: 'ab|cd|'.
+	editor deleter
+		oneBeforeCursor;
+		delete.
+	editor undo.
+	self assert: (self specOf: editor) equals: 'ab|cd|'
+]
diff --git a/src/Album-Tests/AlbTextEditorHistoryTest.class.st b/src/Album-Tests/AlbTextEditorHistoryTest.class.st
index a6ef9d1..81a7191 100644
--- a/src/Album-Tests/AlbTextEditorHistoryTest.class.st
+++ b/src/Album-Tests/AlbTextEditorHistoryTest.class.st
@@ -4,6 +4,24 @@ Class {
 	#category : #'Album-Tests-TextEditor'
 }
 
+{ #category : #tests }
+AlbTextEditorHistoryTest >> test_insert_at_two_indices_and_undo_then_redo [
+
+	| editorElement editor |
+	editorElement := 'abcdef' asRopedText onAlbum.
+	editor := editorElement editor.
+	editor inserter
+		at: 1;
+		at: 3;
+		string: 'X';
+		insert.
+	self assert: editor text asString equals: 'aXbcXdef'.
+	editor undo.
+	self assert: editor text asString equals: 'abcdef'.
+	editor redo.
+	self assert: editor text asString equals: 'aXbcXdef'
+]
+
 { #category : #tests }
 AlbTextEditorHistoryTest >> test_insert_one_char_and_undo [
 
@@ -57,6 +75,30 @@ AlbTextEditorHistoryTest >> test_insert_open_close_parentheses_with_selection_an
 	self assert: editor text asString equals: 'abc'.
 ]
 
+{ #category : #tests }
+AlbTextEditorHistoryTest >> test_insert_open_close_parentheses_with_selection_and_undo_then_redo [
+
+	| editorElement editor |
+	editorElement := '' asRopedText onAlbum.
+	editor := editorElement editor.
+	editor inserter
+		at: 0;
+		string: 'abc';
+		insert.
+	editor selecter all select.
+	editor inserter
+		atCursor;
+		string: '(';
+		withoutSelectionDelete;
+		surroundings: (AlbTextEditorSurroundMap newFromArray: { '('. ')'. nil });
+		insert.
+	self assert: editor text asString equals: '(abc)'.
+	editor undo.
+	self assert: editor text asString equals: 'abc'.
+	editor redo.
+	self assert: editor text asString equals: '(abc)'
+]
+
 { #category : #tests }
 AlbTextEditorHistoryTest >> test_insert_select_remove_and_undo_then_redo2 [
 
diff --git a/src/Album-Tests/AlbTextEditorInserterTest.class.st b/src/Album-Tests/AlbTextEditorInserterTest.class.st
index c5eded4..e1039d1 100644
--- a/src/Album-Tests/AlbTextEditorInserterTest.class.st
+++ b/src/Album-Tests/AlbTextEditorInserterTest.class.st
@@ -97,7 +97,7 @@ AlbTextEditorInserterTest >> test_filter_insert_Hello123_onlyLetters [
 AlbTextEditorInserterTest >> test_insert_Hello_atCursorAt_0_and_1_selection_no [
 	
 	| anEditor anEditorElement |
-	"Album is mono cursor, only last moveTo is actually done"
+	"moveTo: keeps a single cursor, so only the last moveTo: counts (see AlbMultiCursorTest for #addCursorAt:)"
 	anEditorElement := self newEditorElementWithMultilineText.
 	anEditor := anEditorElement editor.
 	space deferAndSettle: [
diff --git a/src/Album/AlbEditableMode.class.st b/src/Album/AlbEditableMode.class.st
index 3046a98..d77a9b0 100644
--- a/src/Album/AlbEditableMode.class.st
+++ b/src/Album/AlbEditableMode.class.st
@@ -52,6 +52,8 @@ AlbEditableMode >> defaultShortcuts [
 		  AlbEditorMoveCursorRightShortcut new.
 		  AlbEditorMoveCursorUpShortcut new.
 		  AlbEditorMoveCursorDownShortcut new.
+		  AlbEditorAddCursorAboveShortcut new.
+		  AlbEditorAddCursorBelowShortcut new.
 		  AlbEditorMoveCursorToPreviousWordShortcut new.
 		  AlbEditorMoveCursorToNextWordShortcut new.
 		  AlbEditorMoveCursorToLineStartShortcut new.
diff --git a/src/Album/AlbEditorAddCursorAboveShortcut.class.st b/src/Album/AlbEditorAddCursorAboveShortcut.class.st
new file mode 100644
index 0000000..eb86a83
--- /dev/null
+++ b/src/Album/AlbEditorAddCursorAboveShortcut.class.st
@@ -0,0 +1,46 @@
+"
+I add a cursor one line above the top-most cursor (Ctrl+Alt+Up, or Cmd+Alt+Up on macOS).
+"
+Class {
+	#name : #AlbEditorAddCursorAboveShortcut,
+	#superclass : #AlbEditorShortcut,
+	#category : #'Album-Shortcuts'
+}
+
+{ #category : #'api - combination' }
+AlbEditorAddCursorAboveShortcut >> combinationForMacOS [
+
+	^ BlKeyCombination builder meta alt arrowUp build
+]
+
+{ #category : #accessing }
+AlbEditorAddCursorAboveShortcut >> description [
+
+	^ 'Adds a cursor one line above the top-most cursor.'
+]
+
+{ #category : #initialization }
+AlbEditorAddCursorAboveShortcut >> initialize [
+
+	super initialize.
+	combination := BlKeyCombination builder control alt arrowUp build
+]
+
+{ #category : #accessing }
+AlbEditorAddCursorAboveShortcut >> name [
+
+	^ 'Add cursor above'
+]
+
+{ #category : #evaluation }
+AlbEditorAddCursorAboveShortcut >> performOnEditor: aTextEditor element: anEditorElement dueTo: aShortcutEvent [
+
+	| anIndex |
+	anIndex := aTextEditor navigator
+		findTextIndexAboveCursor: aTextEditor cursors first
+		ifAbsent: [ ^ self ].
+	aTextEditor deselecter
+		all;
+		deselect.
+	aTextEditor addCursorAt: anIndex
+]
diff --git a/src/Album/AlbEditorAddCursorBelowShortcut.class.st b/src/Album/AlbEditorAddCursorBelowShortcut.class.st
new file mode 100644
index 0000000..29ae1bb
--- /dev/null
+++ b/src/Album/AlbEditorAddCursorBelowShortcut.class.st
@@ -0,0 +1,46 @@
+"
+I add a cursor one line below the bottom-most cursor (Ctrl+Alt+Down, or Cmd+Alt+Down on macOS).
+"
+Class {
+	#name : #AlbEditorAddCursorBelowShortcut,
+	#superclass : #AlbEditorShortcut,
+	#category : #'Album-Shortcuts'
+}
+
+{ #category : #'api - combination' }
+AlbEditorAddCursorBelowShortcut >> combinationForMacOS [
+
+	^ BlKeyCombination builder meta alt arrowDown build
+]
+
+{ #category : #accessing }
+AlbEditorAddCursorBelowShortcut >> description [
+
+	^ 'Adds a cursor one line below the bottom-most cursor.'
+]
+
+{ #category : #initialization }
+AlbEditorAddCursorBelowShortcut >> initialize [
+
+	super initialize.
+	combination := BlKeyCombination builder control alt arrowDown build
+]
+
+{ #category : #accessing }
+AlbEditorAddCursorBelowShortcut >> name [
+
+	^ 'Add cursor below'
+]
+
+{ #category : #evaluation }
+AlbEditorAddCursorBelowShortcut >> performOnEditor: aTextEditor element: anEditorElement dueTo: aShortcutEvent [
+
+	| anIndex |
+	anIndex := aTextEditor navigator
+		findTextIndexBelowCursor: aTextEditor cursors last
+		ifAbsent: [ ^ self ].
+	aTextEditor deselecter
+		all;
+		deselect.
+	aTextEditor addCursorAt: anIndex
+]
diff --git a/src/Album/AlbEditorDeselectAllShortcut.class.st b/src/Album/AlbEditorDeselectAllShortcut.class.st
index ba41e3a..3f7e191 100644
--- a/src/Album/AlbEditorDeselectAllShortcut.class.st
+++ b/src/Album/AlbEditorDeselectAllShortcut.class.st
@@ -6,7 +6,8 @@ Class {
 
 { #category : #accessing }
 AlbEditorDeselectAllShortcut >> description [
-	^ 'Deselects any currently selected text.'
+
+	^ 'Deselects any currently selected text and keeps only the primary cursor.'
 ]
 
 { #category : #initialization }
@@ -24,5 +25,6 @@ AlbEditorDeselectAllShortcut >> name [
 { #category : #evaluation }
 AlbEditorDeselectAllShortcut >> performOnEditor: aTextEditor element: aEditorElement dueTo: aShortcutEvent [
 
-	aTextEditor selectNone
+	aTextEditor selectNone.
+	aTextEditor removeSecondaryCursors
 ]
diff --git a/src/Album/AlbExtendSelectionCommand.class.st b/src/Album/AlbExtendSelectionCommand.class.st
index 47f83f1..ed1ad00 100644
--- a/src/Album/AlbExtendSelectionCommand.class.st
+++ b/src/Album/AlbExtendSelectionCommand.class.st
@@ -7,8 +7,7 @@ Class {
 		'toDeselect',
 		'toMoveCursor',
 		'toAddCursor',
-		'shouldResetDesiredCoordinate',
-		'toRemoveCursors'
+		'shouldResetDesiredCoordinate'
 	],
 	#category : #'Album-Model-Operators'
 }
@@ -18,7 +17,7 @@ AlbExtendSelectionCommand >> editor: anEditor [
 	editor := anEditor
 ]
 
-{ #category : #accessing }
+{ #category : #initialization }
 AlbExtendSelectionCommand >> initialize [
 	super initialize.
 
@@ -26,7 +25,6 @@ AlbExtendSelectionCommand >> initialize [
 	toDeselect := OrderedCollection new.
 	toMoveCursor := nil.
 	toAddCursor := nil.
-	toRemoveCursors := OrderedCollection new.
 	shouldResetDesiredCoordinate := true
 ]
 
diff --git a/src/Album/AlbTextEditor.class.st b/src/Album/AlbTextEditor.class.st
index 45f528d..efcbef9 100644
--- a/src/Album/AlbTextEditor.class.st
+++ b/src/Album/AlbTextEditor.class.st
@@ -17,7 +17,8 @@ Class {
 		'isFocused',
 		'cursor',
 		'hasEventHandlerAttribute',
-		'layoutPositionsRange'
+		'layoutPositionsRange',
+		'secondaryCursors'
 	],
 	#classInstVars : [
 		'isDebug'
@@ -42,6 +43,15 @@ AlbTextEditor class >> isDebug: aBoolean [
 	isDebug := aBoolean
 ]
 
+{ #category : #'cursor - management' }
+AlbTextEditor >> addCursorAt: aTextIndex [
+	"Add a cursor at a given text index. Nothing happens if a cursor is already there"
+
+	self navigator
+		addCursorAt: aTextIndex;
+		apply
+]
+
 { #category : #'api - shortcuts' }
 AlbTextEditor >> addEditorShortcut: aTextEditorShortcut [
 
@@ -106,14 +116,11 @@ AlbTextEditor >> copy: aFromIndex to: aToIndex [
 
 { #category : #'text - copy/paste' }
 AlbTextEditor >> copySelected [
-	"Copy currently selected text to the clipboard"
-	
+	"Copy currently selected text to the clipboard. Several selections are copied one per line"
+
 	self selection isEmpty
 		ifTrue: [ ^ self ].
-		
-	self
-		copy: self selection from
-		to: self selection to
+	Clipboard clipboardText: (String cr join: self selectedTexts)
 ]
 
 { #category : #accessing }
@@ -132,10 +139,10 @@ AlbTextEditor >> cursor: aCursor [
 
 { #category : #accessing }
 AlbTextEditor >> cursors [
+	"Return all cursors (the primary one included) sorted by text position"
 
-	self deprecated: 'Use #cursor'.
-
-	^  { self cursor } 
+	<return: #Array of: #AlbTextEditorCursor>
+	^ ((self secondaryCursors copyWith: self cursor) asSortedCollection: [ :a :b | a position <= b position ]) asArray
 ]
 
 { #category : #'text - copy/paste' }
@@ -153,14 +160,20 @@ AlbTextEditor >> cut: aFromIndex to: aToIndex [
 { #category : #'text - copy/paste' }
 AlbTextEditor >> cutSelected [
 	"Copy currently selected text to the clipboard and remove it from the editor.
+	Several selections are copied one per line and each of them is removed.
 	Note: I update the cursor location and selection"
-	
+
 	self selection isEmpty
 		ifTrue: [ ^ self ].
-	
-	self
-		cut: self selection from
-		to: self selection to
+	self selectedTexts size > 1
+		ifFalse: [
+			^ self
+				cut: self selection from
+				to: self selection to ].
+	self copySelected.
+	self deleter
+		selected;
+		delete
 ]
 
 { #category : #initialization }
@@ -260,6 +273,12 @@ AlbTextEditor >> hasEventHandlerAttribute [
 	^ hasEventHandlerAttribute ifNil: [ false ]
 ]
 
+{ #category : #testing }
+AlbTextEditor >> hasMultipleCursors [
+
+	^ self secondaryCursors notEmpty
+]
+
 { #category : #'text - selection' }
 AlbTextEditor >> hasSelection [
 	"Return true of there is at least one selected character, false otherwise"
@@ -285,17 +304,15 @@ AlbTextEditor >> history: aTextEditorHistory [
 AlbTextEditor >> initialize [
 
 	super initialize.
-
 	hasEventHandlerAttribute := false.
 	filter := AlbTextEditorNoInputFilter new.
 	cursor := self defaultCursor.
+	secondaryCursors := OrderedCollection new.
 	selection := self defaultSelection.
 	selectionRecorder := self defaultSelectionRecorder.
 	shortcuts := AlbTextEditorShortcuts new.
 	history := AlbTextEditorHistory new.
-
 	isFocused := false.
-
 	self text: self defaultText
 ]
 
@@ -765,6 +782,16 @@ AlbTextEditor >> removeEditorShortcuts: aCollectionOfTextEditorShortcut [
 	aCollectionOfTextEditorShortcut do: [ :eachShortcut | self removeEditorShortcut: eachShortcut ]
 ]
 
+{ #category : #'cursor - management' }
+AlbTextEditor >> removeSecondaryCursors [
+	"Keep only the primary cursor"
+
+	self hasMultipleCursors ifFalse: [ ^ self ].
+	self navigator
+		removeSecondaryCursors;
+		apply
+]
+
 { #category : #'api - save state' }
 AlbTextEditor >> restoreState: aTextEditorMemento [
 
@@ -775,24 +802,20 @@ AlbTextEditor >> restoreState: aTextEditorMemento [
 AlbTextEditor >> restoreText: aText [
 
 	"before changing the text we must unsubscribe from existing one"
-
 	text ifNotNil: [ text unsubscribe: self ].
 	self history setUpToStart.
 	cursor := self defaultCursor.
-
+	secondaryCursors := OrderedCollection new.
 	text := aText.
 	" then subscribe to internal text state change (insertion/deletion/attribute change) "
 	self initializeText: text.
-
 	"Replacing text instance means that we can not guarantee structural integrity
 	of existing cache and have to rebuild it invalidating the whole underlying model structure"
 	segmentCollector
 		ifNil: [ segmentCollector := self newSegmentCollector ]
 		ifNotNil: [ segmentCollector resetCache ].
 	segmentCollector text: text.
-
 	self onTextReplaced.
-
 	"notify UI about structural update"
 	self notifyChanged
 ]
@@ -811,6 +834,13 @@ AlbTextEditor >> saveState: aTextEditorMemento [
 	^ aTextEditorMemento saveStateOf: self
 ]
 
+{ #category : #'accessing - cursors' }
+AlbTextEditor >> secondaryCursors [
+	"Return the additional cursors, besides the primary #cursor"
+
+	^ secondaryCursors ifNil: [ secondaryCursors := OrderedCollection new ]
+]
+
 { #category : #accessing }
 AlbTextEditor >> segmentCollector [
 	<return: #AlbTextEditorSegmentCollector>
@@ -856,6 +886,15 @@ AlbTextEditor >> selectedText [
 		  ifFalse: [ self text from: 1 to: 0 ]
 ]
 
+{ #category : #'text - copy/paste' }
+AlbTextEditor >> selectedTexts [
+	"Return the text of every selected interval, in text order"
+
+	^ Array streamContents: [ :aStream |
+		self selection do: [ :eachMonotoneSelection |
+			aStream nextPut: (self text from: eachMonotoneSelection from + 1 to: eachMonotoneSelection to) asString ] ]
+]
+
 { #category : #'api - modification' }
 AlbTextEditor >> selecter [
 	<return: #AlbTextEditorSelecter>
diff --git a/src/Album/AlbTextEditorAbstractSegmentPiece.class.st b/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
index dda7d18..55ea3a4 100644
--- a/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
+++ b/src/Album/AlbTextEditorAbstractSegmentPiece.class.st
@@ -5,21 +5,16 @@ Class {
 	#classTraits : 'TAlbTextEditorTextualPiece classTrait',
 	#instVars : [
 		'segment',
-		'currentCursor'
+		'currentCursor',
+		'currentCursors'
 	],
 	#category : #'Album-Model-Segment'
 }
 
 { #category : #updating }
 AlbTextEditorAbstractSegmentPiece >> addCursor: aPieceElement of: aLineSegment in: anEditorElement [
-	| globalCursor |
-	"if text editor cursor is currently within this segment piece then convert it to a local one"
 
-	globalCursor := anEditorElement cursor.
-	(globalCursor insideSubText: self of: aLineSegment) ifFalse: [^self ].
-	currentCursor := self globalCursorToLocal: globalCursor.
-	"tell to add the new cursor"
-	self onCursorAdded: currentCursor to: aPieceElement in: anEditorElement
+	self syncCursors: aPieceElement of: aLineSegment in: anEditorElement
 ]
 
 { #category : #'instance creation' }
@@ -44,6 +39,19 @@ AlbTextEditorAbstractSegmentPiece >> currentCursor: aCursor [
 	currentCursor := aCursor
 ]
 
+{ #category : #accessing }
+AlbTextEditorAbstractSegmentPiece >> currentCursors [
+	"Return the local cursors displayed by this piece, as associations local cursor -> isPrimary"
+
+	^ currentCursors
+]
+
+{ #category : #accessing }
+AlbTextEditorAbstractSegmentPiece >> currentCursors: aCollection [
+
+	currentCursors := aCollection
+]
+
 { #category : #'api - cursor' }
 AlbTextEditorAbstractSegmentPiece >> globalCursorToLocal: aSingleCursor [
 	"Convert a global cursor as specified in the editor to a local one"
@@ -72,6 +80,16 @@ AlbTextEditorAbstractSegmentPiece >> isText [
 	^ false
 ]
 
+{ #category : #cursor }
+AlbTextEditorAbstractSegmentPiece >> localCursorsOf: aLineSegment in: anEditorElement [
+	"Return the editor cursors located in this piece, converted to local ones, as associations local cursor -> isPrimary"
+
+	| aPrimaryCursor |
+	aPrimaryCursor := anEditorElement editor cursor.
+	^ (anEditorElement editor cursors select: [ :eachCursor | eachCursor insideSubText: self of: aLineSegment ])
+		collect: [ :eachCursor | (self globalCursorToLocal: eachCursor) -> (eachCursor == aPrimaryCursor) ]
+]
+
 { #category : #'cursor - hooks' }
 AlbTextEditorAbstractSegmentPiece >> onCursorAdded: aCursor to: aPieceElement in: anEditorElement [
 	"Is sent when a cursor is added to a given piece element within provided editor element"
@@ -83,6 +101,17 @@ AlbTextEditorAbstractSegmentPiece >> onCursorAdded: aCursor to: aPieceElement in
 			cursorPosition: aCursor position)
 ]
 
+{ #category : #cursor }
+AlbTextEditorAbstractSegmentPiece >> onCursorAdded: aCursor to: aPieceElement in: anEditorElement primary: isPrimary [
+	"Is sent when a cursor is added to a given piece element within provided editor element"
+
+	aPieceElement dispatchEvent: (AlbTextEditorShowCursorRequest new
+		editorElement: anEditorElement;
+		hasFocus: anEditorElement isFocused;
+		cursorPosition: aCursor position;
+		isPrimary: isPrimary)
+]
+
 { #category : #'cursor - hooks' }
 AlbTextEditorAbstractSegmentPiece >> onCursorRemoved: aCursor from: aPieceElement in: anEditorElement [
 	"Is sent when a cursor is removed from a given piece element within provided editor element"
@@ -96,9 +125,10 @@ AlbTextEditorAbstractSegmentPiece >> onCursorRemoved: aCursor from: aPieceElemen
 { #category : #updating }
 AlbTextEditorAbstractSegmentPiece >> removeCursor: aPieceElement of: aLineSegment in: anEditorElement [
 
-	currentCursor ifNil: [ ^ self ].
-	self onCursorRemoved: currentCursor from: aPieceElement in: anEditorElement.
-	"update the current cursor"
+	currentCursors
+		ifNotNil: [ :theCursors | theCursors do: [ :each | self onCursorRemoved: each key from: aPieceElement in: anEditorElement ] ]
+		ifNil: [ currentCursor ifNotNil: [ self onCursorRemoved: currentCursor from: aPieceElement in: anEditorElement ] ].
+	currentCursors := nil.
 	currentCursor := nil
 ]
 
@@ -123,44 +153,36 @@ AlbTextEditorAbstractSegmentPiece >> segment: anObject [
 
 { #category : #updating }
 AlbTextEditorAbstractSegmentPiece >> setCursor: aPieceElement of: aLineSegment in: anEditorElement [
-	| aFocusRequest localCursor globalCursor |
-	"get the global cursor "
-	globalCursor := anEditorElement cursor.
-	"if text editor cursor is currently within this segment piece then convert it to a local one"
-	(globalCursor insideSubText: self of: aLineSegment) ifTrue: [ localCursor := self globalCursorToLocal: globalCursor ].
-	
-	"update current cursors"
-	currentCursor := localCursor.
-
-	"tell to add new cursors"
-	currentCursor ifNotNil: [ self onCursorAdded: currentCursor to: aPieceElement in: anEditorElement ].
 
+	| aFocusRequest |
+	self syncCursors: aPieceElement of: aLineSegment in: anEditorElement.
 	"set the focus"
 	aFocusRequest := anEditorElement isFocused
 		ifTrue: [ AlbTextEditorFocusRequest new ]
 		ifFalse: [ AlbTextEditorBlurRequest new ].
-	aPieceElement
-		dispatchEvent: (aFocusRequest editorElement: anEditorElement)
+	aPieceElement dispatchEvent: (aFocusRequest editorElement: anEditorElement)
+]
+
+{ #category : #cursor }
+AlbTextEditorAbstractSegmentPiece >> syncCursors: aPieceElement of: aLineSegment in: anEditorElement [
+	"Display exactly the editor cursors located in this piece"
+
+	self removeCursor: aPieceElement of: aLineSegment in: anEditorElement.
+	currentCursors := self localCursorsOf: aLineSegment in: anEditorElement.
+	currentCursors ifEmpty: [ ^ currentCursors := nil ].
+	currentCursor := (currentCursors detect: [ :each | each value ] ifNone: [ currentCursors first ]) key.
+	currentCursors do: [ :each |
+		self
+			onCursorAdded: each key
+			to: aPieceElement
+			in: anEditorElement
+			primary: each value ]
 ]
 
 { #category : #updating }
 AlbTextEditorAbstractSegmentPiece >> updateCursor: aPieceElement of: aLineSegment in: anEditorElement [
-	| globalCursor localCursor |
-self flag: 'to be checked because of failing tests AlbTextEditorNavigatorTest>>test_cursor_add_at_1_in_multiline'.
-	"if text editor cursor is currently within this segment piece then convert it to a local one"
-
-	globalCursor := anEditorElement cursor.
-
-	(globalCursor insideSubText: self of: aLineSegment) ifTrue: [ localCursor := self globalCursorToLocal: globalCursor ].
-	
-	"tell to remove the deleted cursor"
-	currentCursor ifNotNil: [ self onCursorRemoved: currentCursor from: aPieceElement in: anEditorElement ].
-
-	"update the current cursor"
-	currentCursor := localCursor.
 
-	"tell to add the new cursor"
-	currentCursor ifNotNil: [ self onCursorAdded: currentCursor to: aPieceElement in: anEditorElement ]
+	self syncCursors: aPieceElement of: aLineSegment in: anEditorElement
 ]
 
 { #category : #updating }
diff --git a/src/Album/AlbTextEditorDeleter.class.st b/src/Album/AlbTextEditorDeleter.class.st
index 0b14192..3200250 100644
--- a/src/Album/AlbTextEditorDeleter.class.st
+++ b/src/Album/AlbTextEditorDeleter.class.st
@@ -78,15 +78,13 @@ AlbTextEditorDeleter >> computeSelectionMovement: aMonotoneSelection [
 
 { #category : #'api - processing' }
 AlbTextEditorDeleter >> delete [
-	"Perform deletion operation"
+	"Perform deletion operation. All intervals are deleted as a single undoable step"
 
-	shouldUpdateCursor
-		ifTrue: [ self updateCursors ].
-
-	shouldUpdateSelection
-		ifTrue: [ self updateSelection ].
-
-	deletionIntervals reverseDo: [ :aMonotoneSelection | self privateDelete: aMonotoneSelection from to: aMonotoneSelection to]
+	editor history groupDuring: [
+		shouldUpdateCursor ifTrue: [ self updateCursors ].
+		shouldUpdateSelection ifTrue: [ self updateSelection ].
+		deletionIntervals reverseDo: [ :aMonotoneSelection |
+			self privateDelete: aMonotoneSelection from to: aMonotoneSelection to ] ]
 ]
 
 { #category : #'api - configuration' }
@@ -115,33 +113,31 @@ AlbTextEditorDeleter >> isDeleter [
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> oneAfterCursor [
-	"Delete one symbol after the cursor"
-		
-	| aCursor |
-	aCursor := self cursor.
-	self
-		from: aCursor position
-		to: ((aCursor position + 1) min: self text size)
+	"Delete one symbol after every cursor"
+
+	editor cursors do: [ :eachCursor |
+		self
+			from: eachCursor position
+			to: ((eachCursor position + 1) min: self text size) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> oneAfterCursorIfOutsideOfSelection [
-	"Delete one symbol after the cursor but only if there is no selection nearby"
-		
-	| aCursor |
-	aCursor := self cursor.
-	(self selection contains: aCursor position)
-		ifFalse: [
-			self
-				from: aCursor position
-				to: ((aCursor position + 1) min: self text size) ]
+	"Delete one symbol after every cursor but only if there is no selection nearby"
+
+	editor cursors do: [ :eachCursor |
+		(self selection contains: eachCursor position)
+			ifFalse: [
+				self
+					from: eachCursor position
+					to: ((eachCursor position + 1) min: self text size) ] ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> oneBeforeCursor [
-	"Delete one symbol before the cursor"
+	"Delete one symbol before every cursor"
 
-	self oneBeforeCursor: self cursor
+	editor cursors do: [ :eachCursor | self oneBeforeCursor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
@@ -155,12 +151,11 @@ AlbTextEditorDeleter >> oneBeforeCursor: aCursor [
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> oneBeforeCursorIfOutsideOfSelection [
-	"Delete one symbol before the cursor but only if there is no selection nearby"
+	"Delete one symbol before every cursor but only if there is no selection nearby"
 
-	| aCursor |
-	aCursor := self cursor.
-	(self selection contains: aCursor position)
-		ifFalse: [ self oneBeforeCursor: aCursor ]
+	editor cursors do: [ :eachCursor |
+		(self selection contains: eachCursor position)
+			ifFalse: [ self oneBeforeCursor: eachCursor ] ]
 ]
 
 { #category : #private }
@@ -193,37 +188,40 @@ AlbTextEditorDeleter >> selected [
 
 { #category : #'api - configuration' }
 AlbTextEditorDeleter >> surroundings: aDictionaryOrArray [
-	"Delete the surrounding around the cursor (if there is any) but only if the cursor is not part of the selection"
-	| theAssociations aCursor |
-	
+	"Delete the surrounding around every cursor (if there is any) but only if the cursor is not part of the selection"
+
+	| theAssociations |
 	theAssociations := aDictionaryOrArray isArray
 		ifFalse: [ aDictionaryOrArray associations ]
 		ifTrue: [ aDictionaryOrArray ].
-	
-	aCursor := self cursor.
-	(self selection contains: aCursor position)
-		ifFalse: [
-			theAssociations
-				detect: [ :eachReplacement |
-					(self hasString: eachReplacement key beforeCursor: aCursor)
-						and: [ self hasString: eachReplacement value afterCursor: aCursor ] ]
-				ifFound: [ :aReplacement |
-					self
-						from: aCursor position - aReplacement key size
-						to: aCursor position + aReplacement value size ] ]
+	editor cursors do: [ :eachCursor |
+		(self selection contains: eachCursor position)
+			ifFalse: [
+				theAssociations
+					detect: [ :eachReplacement |
+						(self hasString: eachReplacement key beforeCursor: eachCursor)
+							and: [ self hasString: eachReplacement value afterCursor: eachCursor ] ]
+					ifFound: [ :aReplacement |
+						self
+							from: eachCursor position - aReplacement key size
+							to: eachCursor position + aReplacement value size ] ] ]
 ]
 
 { #category : #private }
 AlbTextEditorDeleter >> updateCursors [
-	| aCursor aCursorDelta |
-	
-	aCursor := self cursor.
-	aCursorDelta := self computeCursorMovement: aCursor.
-	aCursorDelta isZero
-		ifFalse: [ self editor navigator
-			dueTo: self;
-			move: aCursor by: aCursorDelta;
-			apply ]
+
+	| aNavigator hasMoves |
+	aNavigator := self editor navigator
+		dueTo: self;
+		yourself.
+	hasMoves := false.
+	editor cursors do: [ :eachCursor |
+		| aCursorDelta |
+		aCursorDelta := self computeCursorMovement: eachCursor.
+		aCursorDelta isZero ifFalse: [
+			hasMoves := true.
+			aNavigator move: eachCursor by: aCursorDelta ] ].
+	hasMoves ifTrue: [ aNavigator apply ]
 ]
 
 { #category : #private }
diff --git a/src/Album/AlbTextEditorHistoryCursorMovementCommand.class.st b/src/Album/AlbTextEditorHistoryCursorMovementCommand.class.st
index ee1252b..ea41a14 100644
--- a/src/Album/AlbTextEditorHistoryCursorMovementCommand.class.st
+++ b/src/Album/AlbTextEditorHistoryCursorMovementCommand.class.st
@@ -20,11 +20,18 @@ AlbTextEditorHistoryCursorMovementCommand >> fromIndices: anObject [
 
 { #category : #'api - undo/redo' }
 AlbTextEditorHistoryCursorMovementCommand >> redoOn: aTextEditor [
+
+	self restoreCursorsAt: toIndices on: aTextEditor
+]
+
+{ #category : #private }
+AlbTextEditorHistoryCursorMovementCommand >> restoreCursorsAt: aCollectionOfIndices on: aTextEditor [
+
 	| aNavigator |
-	
+	aCollectionOfIndices ifEmpty: [ ^ self ].
 	aNavigator := aTextEditor navigator.
-	fromIndices do: [ :eachIndex | aNavigator removeAt: eachIndex ].
-	toIndices do: [ :eachIndex | aNavigator moveTo: eachIndex ].
+	aNavigator moveTo: aCollectionOfIndices first.
+	aCollectionOfIndices allButFirst do: [ :eachIndex | aNavigator addCursorAt: eachIndex ].
 	aNavigator apply
 ]
 
@@ -40,10 +47,6 @@ AlbTextEditorHistoryCursorMovementCommand >> toIndices: anObject [
 
 { #category : #'api - undo/redo' }
 AlbTextEditorHistoryCursorMovementCommand >> undoOn: aTextEditor [
-	| aNavigator |
-	
-	aNavigator := aTextEditor navigator.
-	toIndices do: [ :eachIndex | aNavigator removeAt: eachIndex ].
-	fromIndices do: [ :eachIndex | aNavigator moveTo: eachIndex ].
-	aNavigator apply
+
+	self restoreCursorsAt: fromIndices on: aTextEditor
 ]
diff --git a/src/Album/AlbTextEditorInserter.class.st b/src/Album/AlbTextEditorInserter.class.st
index 24c6edf..10b6a1b 100644
--- a/src/Album/AlbTextEditorInserter.class.st
+++ b/src/Album/AlbTextEditorInserter.class.st
@@ -42,7 +42,9 @@ AlbTextEditorInserter >> at: anIndex [
 
 { #category : #'api - configuration' }
 AlbTextEditorInserter >> atCursor [
-	self at: self cursor position
+	"Insert at every cursor"
+
+	editor cursors do: [ :eachCursor | self at: eachCursor position ]
 ]
 
 { #category : #'api - configuration' }
@@ -95,9 +97,12 @@ AlbTextEditorInserter >> computeSelection: aSelection afterInserted: aText at: a
 { #category : #'api - configuration' }
 AlbTextEditorInserter >> crLineEndingWithWhitespace [
 	"Insert a Cr line ending
-	additionally adding a whitespace from the previous line according to a cursor"
+	additionally adding a whitespace from the previous line according to each insertion location"
 
-	self text: String cr, (self findWhitespaceOfLineBefore: self cursor position)
+	insertionIndices ifEmpty: [ ^ self text: String cr , (self findWhitespaceOfLineBefore: self cursor position) ].
+	insertionIndices do: [ :eachAssociation |
+		eachAssociation value: String cr , (self findWhitespaceOfLineBefore: eachAssociation key) ].
+	text := insertionIndices first value
 ]
 
 { #category : #private }
@@ -201,8 +206,8 @@ AlbTextEditorInserter >> insert [
 						(self hasString: eachAssociation value afterCursor: (AlbTextEditorCursor position: anIndex))
 							ifTrue: [ 
 								shouldUpdateCursor ifTrue: [ 
-									self cursor position = anIndex ifTrue: [ 
-										theCursorMovements add: self cursor -> (anIndex + eachAssociation value size) ] ] ]
+									(editor cursors detect: [ :each | each position = anIndex ] ifNone: [ nil ]) ifNotNil: [ :aCursor | 
+										theCursorMovements add: aCursor -> (anIndex + eachAssociation value size) ] ] ]
 							ifFalse: [ 
 								theInsertions add: { 
 										(#index -> anIndex).
@@ -279,9 +284,12 @@ AlbTextEditorInserter >> lineEnding [
 { #category : #'api - configuration' }
 AlbTextEditorInserter >> lineEndingWithWhitespace [
 	"Insert a line ending (Cr, Lf or CrLf depending on the current platform)
-	additionally  adding a whitespace from the previous line according to a cursor"
+	additionally adding a whitespace from the previous line according to each insertion location"
 
-	self text: OSPlatform current lineEnding, (self findWhitespaceOfLineBefore: self cursor position)
+	insertionIndices ifEmpty: [ ^ self text: OSPlatform current lineEnding , (self findWhitespaceOfLineBefore: self cursor position) ].
+	insertionIndices do: [ :eachAssociation |
+		eachAssociation value: OSPlatform current lineEnding , (self findWhitespaceOfLineBefore: eachAssociation key) ].
+	text := insertionIndices first value
 ]
 
 { #category : #'api - configuration' }
@@ -357,46 +365,48 @@ AlbTextEditorInserter >> privateInsertStrings: aCollectionOfString atAll: aColle
 
 { #category : #private }
 AlbTextEditorInserter >> privateUpdateCursorsAfterInsertion: aText at: anIndex [
-	| aCursor aCursorDelta |
-	
-	aCursor := self cursor.
-	aCursorDelta := 
-			self
-				computeIndexMovement: aCursor position
-				afterInserted: aText
-				at: anIndex.
-
-	aCursorDelta isZero
-		ifFalse: [
-			editor navigator
-				context: self context;
-				dueTo: self;
-				move: aCursor by: aCursorDelta;
-				apply ]
+
+	| aNavigator hasMoves |
+	aNavigator := editor navigator
+		context: self context;
+		dueTo: self;
+		yourself.
+	hasMoves := false.
+	editor cursors do: [ :eachCursor |
+		| aCursorDelta |
+		aCursorDelta := self
+			computeIndexMovement: eachCursor position
+			afterInserted: aText
+			at: anIndex.
+		aCursorDelta isZero ifFalse: [
+			hasMoves := true.
+			aNavigator move: eachCursor by: aCursorDelta ] ].
+	hasMoves ifTrue: [ aNavigator apply ]
 ]
 
 { #category : #private }
 AlbTextEditorInserter >> privateUpdateCursorsAfterInsertion: aText withSurround: aSurroundText at: aTextIndex [
-	| theIndices aCursor aCursorDelta |
 
+	| theIndices aNavigator hasMoves |
 	theIndices := self privateComputeCursorIndices: aText withSurround: aSurroundText at: aTextIndex.
-
-	aCursor := self cursor.
-	aCursorDelta := self
-		computeIndexMovement: aCursor position
-		afterInserted: aText
-		at: theIndices first.
-
-	aCursorDelta := aCursorDelta + (self
-		computeIndexMovement: aCursor position
-		afterInserted: aSurroundText
-		at: theIndices second + aText size).
-
-	aCursorDelta isZero
-		ifFalse: [ editor navigator
-			dueTo: self;
-			move: aCursor by: aCursorDelta;
-			apply ]
+	aNavigator := editor navigator
+		dueTo: self;
+		yourself.
+	hasMoves := false.
+	editor cursors do: [ :eachCursor |
+		| aCursorDelta |
+		aCursorDelta := self
+			computeIndexMovement: eachCursor position
+			afterInserted: aText
+			at: theIndices first.
+		aCursorDelta := aCursorDelta + (self
+			computeIndexMovement: eachCursor position
+			afterInserted: aSurroundText
+			at: theIndices second + aText size).
+		aCursorDelta isZero ifFalse: [
+			hasMoves := true.
+			aNavigator move: eachCursor by: aCursorDelta ] ].
+	hasMoves ifTrue: [ aNavigator apply ]
 ]
 
 { #category : #'private - accessing' }
diff --git a/src/Album/AlbTextEditorLineSegmentHolder.class.st b/src/Album/AlbTextEditorLineSegmentHolder.class.st
index 28f34f4..2b13e90 100644
--- a/src/Album/AlbTextEditorLineSegmentHolder.class.st
+++ b/src/Album/AlbTextEditorLineSegmentHolder.class.st
@@ -147,7 +147,7 @@ AlbTextEditorLineSegmentHolder >> hasCursor [
 
 	| aTextEditor |
 	aTextEditor := self infiniteElement editor.
-	^ aTextEditor cursor insideSegment: segment
+	^ aTextEditor cursors anySatisfy: [ :eachCursor | eachCursor insideSegment: segment ]
 ]
 
 { #category : #'private - testing' }
@@ -315,6 +315,8 @@ AlbTextEditorLineSegmentHolder >> updateSegment: anEditorSegment [
 						https://github.com/feenkcom/gtoolkit/issues/892"
 				                    eachSegmentPiece currentCursor:
 					                    eachPiece currentCursor.
+				                    eachSegmentPiece currentCursors:
+					                    eachPiece currentCursors.
 				                    theSegmentElements do: [ :eachSegmentElement |
 					                    eachPiece
 						                    updateText: eachSegmentElement
diff --git a/src/Album/AlbTextEditorMouseHandler.class.st b/src/Album/AlbTextEditorMouseHandler.class.st
index a9edad1..1b2afa0 100644
--- a/src/Album/AlbTextEditorMouseHandler.class.st
+++ b/src/Album/AlbTextEditorMouseHandler.class.st
@@ -29,6 +29,15 @@ AlbTextEditorMouseHandler >> mouseDownEvent: anEvent [
 		              findTextIndexAtScreenPosition: aScreenPosition
 		              ifAbsent: [ nil ].
 
+	"Alt (Option on macOS) click toggles an additional cursor"
+	(anEvent modifiers isAlt and: [ aTextIndex notNil and: [ element isEditable ] ]) ifTrue: [
+		editor deselecter all deselect.
+		(editor cursors anySatisfy: [ :each | each position = aTextIndex ])
+			ifTrue: [ aNavigator removeCursorAt: aTextIndex ]
+			ifFalse: [ aNavigator addCursorAt: aTextIndex ].
+		element requestFocus.
+		aNavigator apply.
+		^ self ].
 	anEvent modifiers isShift
 		ifTrue: [
 			aTextIndex ifNotNil: [
diff --git a/src/Album/AlbTextEditorNavigator.class.st b/src/Album/AlbTextEditorNavigator.class.st
index 8148b1f..38da4f2 100644
--- a/src/Album/AlbTextEditorNavigator.class.st
+++ b/src/Album/AlbTextEditorNavigator.class.st
@@ -13,7 +13,11 @@ Class {
 		'operations',
 		'dueTo',
 		'shouldHistorize',
-		'nextTextPosition'
+		'nextPositions',
+		'cursorsToAdd',
+		'positionsToRemove',
+		'shouldRemoveSecondaries',
+		'shouldMergeWithinSelection'
 	],
 	#category : #'Album-Model-Operators'
 }
@@ -33,19 +37,53 @@ AlbTextEditorNavigator >> addAtScreenPosition: aScreenPosition [
 	self moveToScreenPosition: aScreenPosition 
 ]
 
+{ #category : #'cursor - management' }
+AlbTextEditorNavigator >> addCursorAt: aTextPosition [
+	"Add a new cursor at a given text position, in addition to the existing ones"
+
+	self privateAssertPosition: aTextPosition.
+	cursorsToAdd add: aTextPosition
+]
+
 { #category : #'api - processing' }
 AlbTextEditorNavigator >> apply [
-	| prevTextPosition |
-	
-	prevTextPosition := self cursor position.
-	nextTextPosition := prevTextPosition.
-	operations do: [ :anOperation| anOperation performOn: self ].
-	
+
+	| previousPositions toRemove moves |
+	previousPositions := editor cursors collect: [ :each | each position ].
+	operations do: [ :anOperation | anOperation performOn: self ].
+
+	toRemove := self privateCursorsToRemove.
+	moves := OrderedCollection new.
+	nextPositions keysAndValuesDo: [ :aCursor :aPosition |
+		(toRemove includes: aCursor) ifFalse: [
+			moves add: aCursor -> (aCursor position -> (self privateNormalizePosition: aPosition)) ] ].
+
+	"first remove the cursors from their old location, then update the model,
+	and only then add them back, so that cursors sharing a segment do not hide each other"
+	toRemove do: [ :each | self notifyCursorRemoved: each ].
+	moves do: [ :each | self notifyCursorRemoved: (AlbTextEditorCursor position: each value key) ].
+
+	moves do: [ :each |
+		each key position: each value value.
+		shouldResetDesiredCoordinate ifTrue: [ each key resetDesiredCoordinate ] ].
+	editor secondaryCursors removeAll: toRemove.
+	cursorsToAdd do: [ :aPosition |
+		editor secondaryCursors add: (AlbTextEditorCursor position: (self privateNormalizePosition: aPosition)) ].
+	self privateMergeCursors do: [ :each | self notifyCursorRemoved: each ].
+
+	self selection ifEmpty: [ editor cursors do: [ :each | self notifyCursorAdded: each ] ].
+
+	moves do: [ :each |
+		each value key ~= each value value ifTrue: [
+			editor dispatchEvent: (AlbCursorMovedEvent
+				cursor: each key
+				from: each value key
+				to: each value value
+				dueTo: (dueTo ifNil: [ self ])) ] ].
 	shouldHistorize ifTrue: [
 		editor history
-			cursorsMovedFrom: {prevTextPosition} to: { nextTextPosition } ].
-
-	self privateMoveCursor: self cursor to: nextTextPosition.
+			cursorsMovedFrom: previousPositions
+			to: (editor cursors collect: [ :each | each position ]) ].
 	dueTo := nil
 ]
 
@@ -61,11 +99,16 @@ AlbTextEditorNavigator >> dueTo: aTextEditorOperator [
 
 { #category : #initialization }
 AlbTextEditorNavigator >> initialize [
+
 	super initialize.
 	operations := OrderedCollection new.
+	nextPositions := IdentityDictionary new.
+	cursorsToAdd := OrderedCollection new.
+	positionsToRemove := OrderedCollection new.
+	shouldRemoveSecondaries := false.
+	shouldMergeWithinSelection := false.
 	shouldResetDesiredCoordinate := true.
-	shouldHistorize := false.
-
+	shouldHistorize := false
 ]
 
 { #category : #'api - configuration' }
@@ -84,97 +127,110 @@ AlbTextEditorNavigator >> move: aCursor to: aTextPosition [
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveBy: aDelta [
-	"Move all cursors by a given delta. The operation is only applied on existing cursor, not the ones that will be added"
+	"Move all cursors by a given delta. The operation is only applied on existing cursors, not the ones that will be added"
 
-	operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: self cursor) delta: aDelta)
+	editor cursors do: [ :eachCursor |
+		operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: eachCursor) delta: aDelta) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveDown [
 	"Move all cursors down one line"
 
-	operations add: (AlbTextEditorNavigatorMoveDownOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveDownOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveLeft [
+	"Move all cursors one to the left"
 
-	| delta |
-	delta := -1.
-	(self hasString: String crlf beforeCursor: self cursor) ifTrue: [ delta := -2 ].
-	operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: self cursor) delta: delta)
+	editor cursors do: [ :eachCursor |
+		| delta |
+		delta := -1.
+		(self hasString: String crlf beforeCursor: eachCursor) ifTrue: [ delta := -2 ].
+		operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: eachCursor) delta: delta) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveRight [
 	"Move all cursors one to the right"
-	| delta |
-	delta := 1.
-	(self hasString: String crlf afterCursor: self cursor) ifTrue: [ delta := 2 ].
-	operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: self cursor) delta: delta)
+
+	editor cursors do: [ :eachCursor |
+		| delta |
+		delta := 1.
+		(self hasString: String crlf afterCursor: eachCursor) ifTrue: [ delta := 2 ].
+		operations add: ((AlbTextEditorNavigatorMoveByOperation cursor: eachCursor) delta: delta) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveTo: aTextPosition [
 	"Move all cursors to a given position (basically, remove all cursors except one)"
-	self privateAssertPosition: aTextPosition.
-
-	operations add: ((AlbTextEditorNavigatorMoveToOperation cursor: self cursor) position: aTextPosition).
 
+	self privateAssertPosition: aTextPosition.
+	shouldRemoveSecondaries := true.
+	operations add: ((AlbTextEditorNavigatorMoveToOperation cursor: self cursor) position: aTextPosition)
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToEndNextWord [
 	"Move all cursors to the end of the next word"
 
-	operations add: (AlbTextEditorNavigatorMoveToEndNextWordOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveToEndNextWordOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToLineEnd [
 	"Move all cursors to the end of their corresponding lines"
 
-	operations add: (AlbTextEditorNavigatorMoveToLineEndOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveToLineEndOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToLineStart [
 	"Move all cursors to the start of their corresponding lines"
 
-	operations add: (AlbTextEditorNavigatorMoveToLineStartOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveToLineStartOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToScreenPosition: aScreenPosition [
 	"Move all cursors to a given screen position (basically, remove all cursors except one)"
-	operations add: ((AlbTextEditorNavigatorMoveAtScreenPositionOperation cursor: self cursor) screenPosition: aScreenPosition).
+
+	shouldRemoveSecondaries := true.
+	operations add: ((AlbTextEditorNavigatorMoveAtScreenPositionOperation cursor: self cursor) screenPosition: aScreenPosition)
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveToStartPreviousWord [
 	"Move all cursors to the start of the previous word"
 
-	operations add: (AlbTextEditorNavigatorMoveToStartPreviousWordOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveToStartPreviousWordOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveUp [
 	"Move all cursors up one line"
 
-	operations add: (AlbTextEditorNavigatorMoveUpOperation cursor: self cursor)
+	editor cursors do: [ :eachCursor |
+		operations add: (AlbTextEditorNavigatorMoveUpOperation cursor: eachCursor) ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> moveWithin: anInterval [
 	"Move all cursors so that they end up within a given text interval.
-	The operation is only applied on existing cursor, not the ones that will be added"
-	| aCursor |
-
-	aCursor := self cursor.
-	aCursor position < anInterval first
-		ifTrue: [ self move: aCursor to: anInterval first ]
-		ifFalse: [ aCursor position > anInterval last
-			ifTrue: [ self move: aCursor to: anInterval last ] ]
+	The operation is only applied on existing cursors, not the ones that will be added"
+
+	editor cursors do: [ :eachCursor |
+		eachCursor position < anInterval first
+			ifTrue: [ self move: eachCursor to: anInterval first ]
+			ifFalse: [
+				eachCursor position > anInterval last
+					ifTrue: [ self move: eachCursor to: anInterval last ] ] ]
 ]
 
 { #category : #'private - accessing' }
@@ -184,6 +240,77 @@ AlbTextEditorNavigator >> privateAssertPosition: aTextPosition [
 		description: [ 'Cursor position ({1}) must be within the interval [0.. {2}]' format: { aTextPosition . self text size } ].
 ]
 
+{ #category : #private }
+AlbTextEditorNavigator >> privateCursorToKeepAmong: aCollectionOfCursors within: aMonotoneSelection [
+	"Prefer a cursor at an edge of the selection: the primary one if it is there, otherwise the one at the end"
+
+	| atEdges |
+	atEdges := aCollectionOfCursors select: [ :eachCursor |
+		eachCursor position = aMonotoneSelection from or: [ eachCursor position = aMonotoneSelection to ] ].
+	atEdges ifEmpty: [ atEdges := aCollectionOfCursors ].
+	^ atEdges
+		detect: [ :eachCursor | eachCursor == editor cursor ]
+		ifNone: [
+			atEdges
+				detect: [ :eachCursor | eachCursor position = aMonotoneSelection to ]
+				ifNone: [ atEdges first ] ]
+]
+
+{ #category : #private }
+AlbTextEditorNavigator >> privateCursorsToRemove [
+	"Return the cursors to be removed by this navigation. The primary cursor is never part of it:
+	if it must be removed while other cursors survive, one of them is promoted to primary first"
+
+	<return: #IdentitySet>
+	| toRemove |
+	toRemove := IdentitySet new.
+	shouldRemoveSecondaries ifTrue: [ toRemove addAll: editor secondaryCursors ].
+	positionsToRemove do: [ :aPosition |
+		editor cursors
+			detect: [ :each | each position = aPosition ]
+			ifFound: [ :aCursor | toRemove add: aCursor ] ].
+	(toRemove includes: editor cursor) ifFalse: [ ^ toRemove ].
+	toRemove remove: editor cursor.
+	(editor secondaryCursors reject: [ :each | toRemove includes: each ]) ifNotEmpty: [ :theSurvivors |
+		| anOldPrimary |
+		anOldPrimary := editor cursor.
+		editor secondaryCursors remove: theSurvivors first.
+		editor cursor: theSurvivors first.
+		editor secondaryCursors add: anOldPrimary.
+		toRemove add: anOldPrimary ].
+	^ toRemove
+]
+
+{ #category : #private }
+AlbTextEditorNavigator >> privateMergeCursors [
+	"Merge cursors that meet and return the removed ones:
+	- cursors sharing a position (the primary one wins)
+	- cursors within the same selection (one cursor per selection is kept, at its edge)"
+
+	<return: #Collection of: #AlbTextEditorCursor>
+	| removed occupiedPositions |
+	removed := OrderedCollection new.
+	occupiedPositions := Set with: editor cursor position.
+	editor secondaryCursors copy do: [ :eachCursor |
+		(occupiedPositions includes: eachCursor position)
+			ifTrue: [
+				editor secondaryCursors remove: eachCursor.
+				removed add: eachCursor ]
+			ifFalse: [ occupiedPositions add: eachCursor position ] ].
+	shouldMergeWithinSelection ifFalse: [ ^ removed ].
+	self selection do: [ :eachMonotoneSelection |
+		| inside keeper |
+		inside := editor cursors select: [ :eachCursor |
+			eachCursor position between: eachMonotoneSelection from and: eachMonotoneSelection to ].
+		inside size > 1 ifTrue: [
+			keeper := self privateCursorToKeepAmong: inside within: eachMonotoneSelection.
+			inside do: [ :eachCursor |
+				eachCursor == keeper ifFalse: [
+					self privateRemoveCursor: eachCursor keeping: keeper.
+					removed add: eachCursor ] ] ] ].
+	^ removed
+]
+
 { #category : #private }
 AlbTextEditorNavigator >> privateMoveCursor: aCursor to: aTextIndex [
 
@@ -216,12 +343,46 @@ AlbTextEditorNavigator >> privateNormalizePosition: aTextPosition [
 
 { #category : #'private - registration' }
 AlbTextEditorNavigator >> privateRegisterForMove: aCursor by: aDelta [
-	nextTextPosition := self cursor position + aDelta
+
+	nextPositions at: aCursor put: aCursor position + aDelta
 ]
 
 { #category : #'private - registration' }
 AlbTextEditorNavigator >> privateRegisterForMove: aCursor to: aTextPosition [
-	nextTextPosition := aTextPosition
+
+	nextPositions at: aCursor put: aTextPosition
+]
+
+{ #category : #private }
+AlbTextEditorNavigator >> privateRemoveCursor: aCursor keeping: aKeptCursor [
+	"Remove aCursor from the editor. If it is the primary cursor, the kept one becomes primary"
+
+	aCursor == editor cursor
+		ifTrue: [
+			editor secondaryCursors remove: aKeptCursor.
+			editor cursor: aKeptCursor ]
+		ifFalse: [ editor secondaryCursors remove: aCursor ]
+]
+
+{ #category : #'cursor - management' }
+AlbTextEditorNavigator >> removeAt: aTextPosition [
+	"Remove the cursor at a given text position (used by the history)"
+
+	self removeCursorAt: aTextPosition
+]
+
+{ #category : #'cursor - management' }
+AlbTextEditorNavigator >> removeCursorAt: aTextPosition [
+	"Remove the cursor at a given text position. The last remaining cursor is never removed"
+
+	positionsToRemove add: aTextPosition
+]
+
+{ #category : #'cursor - management' }
+AlbTextEditorNavigator >> removeSecondaryCursors [
+	"Keep only the primary cursor"
+
+	shouldRemoveSecondaries := true
 ]
 
 { #category : #'api - events' }
@@ -245,6 +406,14 @@ AlbTextEditorNavigator >> withHistorization [
 	shouldHistorize := true
 ]
 
+{ #category : #accessing }
+AlbTextEditorNavigator >> withMergingWithinSelection [
+	"Also merge cursors that end up within the same selection, keeping one per selection.
+	Only meaningful while selections are being extended: other operations may move cursors before the selection is updated"
+
+	shouldMergeWithinSelection := true
+]
+
 { #category : #'api - configuration' }
 AlbTextEditorNavigator >> withResettingDesiredCoordinate [
 	shouldResetDesiredCoordinate := true
diff --git a/src/Album/AlbTextEditorPaster.class.st b/src/Album/AlbTextEditorPaster.class.st
index e2bfe12..fb69b85 100644
--- a/src/Album/AlbTextEditorPaster.class.st
+++ b/src/Album/AlbTextEditorPaster.class.st
@@ -26,8 +26,10 @@ AlbTextEditorPaster >> at: anIndex [
 ]
 
 { #category : #'api - configuration' }
-AlbTextEditorPaster >> atCursor [	
-	self at: self cursor position
+AlbTextEditorPaster >> atCursor [
+	"Paste at every cursor"
+
+	editor cursors do: [ :eachCursor | self at: eachCursor position ]
 ]
 
 { #category : #'api - configuration' }
@@ -65,18 +67,39 @@ AlbTextEditorPaster >> isEmpty [
 	^ text isEmpty
 ]
 
+{ #category : #private }
+AlbTextEditorPaster >> linesPerInsertion [
+	"Return one line of the pasted text per insertion location, in text order, when there are
+	several locations and exactly as many lines. Return an empty collection otherwise:
+	the whole text is then pasted at every location"
+
+	| theLines |
+	insertionIndices size > 1
+		ifFalse: [ ^ #() ].
+	theLines := text asString lines.
+	^ theLines size = insertionIndices size
+		ifTrue: [ theLines ]
+		ifFalse: [ #() ]
+]
+
 { #category : #'api - processing' }
 AlbTextEditorPaster >> paste [
-	| anInserter |
-	
+
+	| anInserter theLines |
 	anInserter := editor inserter.
 	anInserter inputFilter: inputFilter.
 	anInserter text: text.
 	anInserter shouldDeleteSelected: shouldDeleteSelected.
 	anInserter shouldUpdateCursor: shouldUpdateCursor.
 	anInserter shouldUpdateSelection: shouldUpdateSelection.
-	insertionIndices do: [ :anIndex | anInserter at: anIndex ].
-
+	theLines := self linesPerInsertion.
+	theLines
+		ifEmpty: [ insertionIndices do: [ :anIndex | anInserter at: anIndex ] ]
+		ifNotEmpty: [
+			insertionIndices with: theLines do: [ :anIndex :aLine |
+				anInserter
+					text: aLine;
+					at: anIndex ] ].
 	anInserter insert
 ]
 
diff --git a/src/Album/AlbTextEditorSelecter.class.st b/src/Album/AlbTextEditorSelecter.class.st
index 4aa0d0a..4844da8 100644
--- a/src/Album/AlbTextEditorSelecter.class.st
+++ b/src/Album/AlbTextEditorSelecter.class.st
@@ -44,65 +44,30 @@ AlbTextEditorSelecter >> extendToIndex: anIndex [
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> extendToLineEnd [
-	"Extend selection to the end of the line"
-	|  cmd globalCursor delta |
+	"Extend the selection of every cursor to the end of its line"
 
-	globalCursor := self cursor.
-	delta := (self findTextIndexAtLineEnd: globalCursor) - globalCursor position.
-	cmd := (self
-			privateExtendSelectionRightAt: globalCursor position
-			by: delta) toMoveCursor: globalCursor by: delta.
-	
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateExtendToLineEndFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> extendToLineStart [
+	"Extend the selection of every cursor to the start of its line"
 
-	"Extend selection to the start of the line"
-
-	| cmd delta globalCursor |
-
-	globalCursor := self cursor.
-	delta := globalCursor position
-	         - (self findTextIndexAtLineStart: globalCursor).
-	cmd := (self
-		        privateExtendSelectionLeftAt: globalCursor position
-		        by: delta) toMoveCursor: globalCursor by: delta negated.
-
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateExtendToLineStartFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> extendToNextWordEnd [
-	"Extend selection to the end of the next word"
-	| aCursor aDelta cmd |
+	"Extend the selection of every cursor to the end of the next word"
 
-	aCursor := self cursor.
-	aDelta := (self findWordEndAfter: aCursor position) - aCursor position.
-	cmd := (self
-			privateExtendSelectionRightAt: aCursor position
-			by: aDelta)
-				toMoveCursor: aCursor
-				by: aDelta.
-	
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateExtendToNextWordEndFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> extendToPreviousWordStart [
-	"Extend selection to start of the previous word"
-	| aCursor aDelta cmd |
+	"Extend the selection of every cursor to the start of the previous word"
 
-	aCursor := self cursor.
-	aDelta := aCursor position - (self findWordEnlargedStartBefore: aCursor position).
-	cmd := (self
-			privateExtendSelectionLeftAt: aCursor position
-			by: aDelta)
-				toMoveCursor: aCursor
-				by: aDelta negated.
-	
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateExtendToPreviousWordStartFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
@@ -168,100 +133,30 @@ AlbTextEditorSelecter >> initialize [
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> moveOneDown [
-	"Select and move a cursor one line down"
-	| aCursor newCursorPosition cmd |
+	"Extend or shrink the selection of every cursor by one line down"
 
-	aCursor := self cursor.
-	newCursorPosition := self
-		findTextIndexBelowCursor: aCursor
-		ifAbsent: [
-			(self isCursorOnTheLastLine: aCursor)
-				ifTrue: [ self text size ]
-				ifFalse: [ aCursor position ] ].
-
-	(self selection anySatisfy: [ :aSelection | aCursor position = aSelection from ])
-		ifTrue: [
-			| aDelta |
-			aDelta := newCursorPosition - aCursor position.
-			cmd := AlbExtendSelectionCommand new 
-				editor: editor;
-				toDeselect: { BlSelection from: aCursor position to: newCursorPosition };
-				toMoveCursor: aCursor by: aDelta ]
-		ifFalse: [
-			| aDelta |
-			aDelta := (newCursorPosition min: self text size) - aCursor position.
-			cmd := AlbExtendSelectionCommand new 
-				editor: editor;
-				toSelect: { BlSelection from: aCursor position to: (newCursorPosition min: self text size) };
-				toMoveCursor: aCursor by: aDelta;
-				withoutResettingDesiredCoordinate ].
-		
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateMoveOneDownFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> moveOneToLeft [
-	"Select and move a cursor one character to the left"
-	| cmd aCursor |
+	"Extend or shrink the selection of every cursor by one character to the left"
 
-	aCursor := self cursor.
-	cmd := (self
-			privateExtendSelectionLeftAt: aCursor position
-			by: 1)
-				toMoveCursor: aCursor
-				by: -1.
-			
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateMoveOneToLeftFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> moveOneToRight [
-	"Select and move a cursor one character to the right"
-	| cmd aCursor |
+	"Extend or shrink the selection of every cursor by one character to the right"
 
-	aCursor := self cursor.
-	cmd := (self
-			privateExtendSelectionRightAt: aCursor position
-			by: 1)
-				toMoveCursor: aCursor
-				by: 1.
-	
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateMoveOneToRightFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
 AlbTextEditorSelecter >> moveOneUp [
-	"Select and move a cursor one line up"
-	| aCursor newCursorPosition cmd |
-	
-	aCursor := self cursor.
-	newCursorPosition := self
-		findTextIndexAboveCursor: aCursor
-		ifAbsent: [
-			(self isCursorOnTheFirstLine: aCursor)
-				ifTrue: [ 0 ]
-				ifFalse: [ aCursor position ] ].
-
-	"the cursor is on the right side of the selection, we should deselect from the new potential position to its current location"
-	(self selection anySatisfy: [ :aSelection | aCursor position = aSelection to ])
-		ifTrue: [
-			| aDelta |
-			aDelta := aCursor position - newCursorPosition.
-			cmd := AlbExtendSelectionCommand new 
-				editor: editor;
-				toDeselect: { BlSelection from: newCursorPosition to: aCursor position };
-				toMoveCursor: aCursor by: aDelta negated ]
-		ifFalse: [
-			"the cursor is on the left side of the selection or is not inside any selection, we should extend it to the new potential location"
-			| aDelta |
-			aDelta := aCursor position - newCursorPosition.
-			cmd := AlbExtendSelectionCommand new 
-				editor: editor;
-				toSelect: { BlSelection from: newCursorPosition to: aCursor position };
-				toMoveCursor: aCursor by: aDelta negated;
-				withoutResettingDesiredCoordinate ].
+	"Extend or shrink the selection of every cursor by one line up"
 
-	commands add: cmd
+	editor cursors do: [ :eachCursor | self privateMoveOneUpFor: eachCursor ]
 ]
 
 { #category : #'api - configuration' }
@@ -385,6 +280,63 @@ AlbTextEditorSelecter >> privateExtendSelectionRightAt: aTextPosition by: anAmou
 		toDeselect: toDeselect
 ]
 
+{ #category : #private }
+AlbTextEditorSelecter >> privateExtendToLineEndFor: globalCursor [
+	"Extend selection to the end of the line"
+
+	| cmd delta |
+	delta := (self findTextIndexAtLineEnd: globalCursor) - globalCursor position.
+	cmd := (self
+			privateExtendSelectionRightAt: globalCursor position
+			by: delta) toMoveCursor: globalCursor by: delta.
+	
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateExtendToLineStartFor: globalCursor [
+	"Extend selection to the start of the line"
+
+	| cmd delta |
+	delta := globalCursor position - (self findTextIndexAtLineStart: globalCursor).
+	cmd := (self
+		privateExtendSelectionLeftAt: globalCursor position
+		by: delta)
+			toMoveCursor: globalCursor
+			by: delta negated.
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateExtendToNextWordEndFor: aCursor [
+	"Extend selection to the end of the next word"
+
+	| aDelta cmd |
+	aDelta := (self findWordEndAfter: aCursor position) - aCursor position.
+	cmd := (self
+			privateExtendSelectionRightAt: aCursor position
+			by: aDelta)
+				toMoveCursor: aCursor
+				by: aDelta.
+	
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateExtendToPreviousWordStartFor: aCursor [
+	"Extend selection to start of the previous word"
+
+	| aDelta cmd |
+	aDelta := aCursor position - (self findWordEnlargedStartBefore: aCursor position).
+	cmd := (self
+			privateExtendSelectionLeftAt: aCursor position
+			by: aDelta)
+				toMoveCursor: aCursor
+				by: aDelta negated.
+	
+	commands add: cmd
+]
+
 { #category : #private }
 AlbTextEditorSelecter >> privateFrom: aFromIndex to: aToIndex [
 
@@ -394,19 +346,111 @@ AlbTextEditorSelecter >> privateFrom: aFromIndex to: aToIndex [
 	selection select: aFromIndex to: aToIndex
 ]
 
+{ #category : #private }
+AlbTextEditorSelecter >> privateMoveOneDownFor: aCursor [
+	"Select and move a cursor one line down"
+
+	| newCursorPosition cmd |
+	newCursorPosition := self
+		findTextIndexBelowCursor: aCursor
+		ifAbsent: [
+			(self isCursorOnTheLastLine: aCursor)
+				ifTrue: [ self text size ]
+				ifFalse: [ aCursor position ] ].
+
+	(self selection anySatisfy: [ :aSelection | aCursor position = aSelection from ])
+		ifTrue: [
+			| aDelta |
+			aDelta := newCursorPosition - aCursor position.
+			cmd := AlbExtendSelectionCommand new 
+				editor: editor;
+				toDeselect: { BlSelection from: aCursor position to: newCursorPosition };
+				toMoveCursor: aCursor by: aDelta ]
+		ifFalse: [
+			| aDelta |
+			aDelta := (newCursorPosition min: self text size) - aCursor position.
+			cmd := AlbExtendSelectionCommand new 
+				editor: editor;
+				toSelect: { BlSelection from: aCursor position to: (newCursorPosition min: self text size) };
+				toMoveCursor: aCursor by: aDelta;
+				withoutResettingDesiredCoordinate ].
+		
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateMoveOneToLeftFor: aCursor [
+	"Select and move a cursor one character to the left"
+
+	| cmd |
+	cmd := (self
+			privateExtendSelectionLeftAt: aCursor position
+			by: 1)
+				toMoveCursor: aCursor
+				by: -1.
+			
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateMoveOneToRightFor: aCursor [
+	"Select and move a cursor one character to the right"
+
+	| cmd |
+	cmd := (self
+			privateExtendSelectionRightAt: aCursor position
+			by: 1)
+				toMoveCursor: aCursor
+				by: 1.
+	
+	commands add: cmd
+]
+
+{ #category : #private }
+AlbTextEditorSelecter >> privateMoveOneUpFor: aCursor [
+	"Select and move a cursor one line up"
+
+	| newCursorPosition cmd |
+	newCursorPosition := self
+		findTextIndexAboveCursor: aCursor
+		ifAbsent: [
+			(self isCursorOnTheFirstLine: aCursor)
+				ifTrue: [ 0 ]
+				ifFalse: [ aCursor position ] ].
+
+	"the cursor is on the right side of the selection, we should deselect from the new potential position to its current location"
+	(self selection anySatisfy: [ :aSelection | aCursor position = aSelection to ])
+		ifTrue: [
+			| aDelta |
+			aDelta := aCursor position - newCursorPosition.
+			cmd := AlbExtendSelectionCommand new 
+				editor: editor;
+				toDeselect: { BlSelection from: newCursorPosition to: aCursor position };
+				toMoveCursor: aCursor by: aDelta negated ]
+		ifFalse: [
+			"the cursor is on the left side of the selection or is not inside any selection, we should extend it to the new potential location"
+			| aDelta |
+			aDelta := aCursor position - newCursorPosition.
+			cmd := AlbExtendSelectionCommand new 
+				editor: editor;
+				toSelect: { BlSelection from: newCursorPosition to: aCursor position };
+				toMoveCursor: aCursor by: aDelta negated;
+				withoutResettingDesiredCoordinate ].
+
+	commands add: cmd
+]
+
 { #category : #private }
 AlbTextEditorSelecter >> privatePerformSelectAndDeselectCommands: theCommands [
-	| aDeselecter  |
 
+	| aDeselecter aNavigator |
 	aDeselecter := editor deselecter.
-
 	theCommands do: [ :aCommand |
 		aCommand toDeselectDo: [ :eachSelectionToDeselect |
 			aDeselecter
 				from: eachSelectionToDeselect from
 				to: eachSelectionToDeselect to ] ].
 	aDeselecter deselect.
-
 	theCommands do: [ :aCommand |
 		aCommand toSelectDo: [ :eachSelectionToSelect |
 			self
@@ -415,23 +459,20 @@ AlbTextEditorSelecter >> privatePerformSelectAndDeselectCommands: theCommands [
 	
 	shouldUpdateCursor
 		ifFalse: [ ^ self ].
-	
+	theCommands
+		ifEmpty: [ ^ self ].
+	"Move all cursors with a single navigator"
+	aNavigator := editor navigator.
+	aNavigator dueTo: self.
+	(theCommands allSatisfy: [ :aCommand | aCommand shouldResetDesiredCoordinate ])
+		ifTrue: [ aNavigator withResettingDesiredCoordinate ]
+		ifFalse: [ aNavigator withoutResettingDesiredCoordinate ].
 	theCommands do: [ :aCommand |
-		| aNavigator |
-		aNavigator := editor navigator.
-		aNavigator dueTo: self.
-		
-		aCommand shouldResetDesiredCoordinate
-			ifTrue: [ aNavigator withResettingDesiredCoordinate ]
-			ifFalse: [ aNavigator withoutResettingDesiredCoordinate ].
-		
 		aCommand toMoveCursorDo: [ :eachCursor :anAmount |
 			aNavigator move: eachCursor by: anAmount ].
 		aCommand toAddCursorDo: [ :aCursorPosition |
-			aNavigator moveTo: aCursorPosition ].
-		"aCommand toRemoveCursorsDo: [ :aCursor |
-			aNavigator remove: aCursor ]".
-		aNavigator apply ].
+			aNavigator moveTo: aCursorPosition ] ].
+	aNavigator apply
 ]
 
 { #category : #private }
@@ -479,7 +520,12 @@ AlbTextEditorSelecter >> select [
 	toBeSelected do: [ :aMonotoneSelection | 
 		aMonotoneSelection interval size > 1 ifTrue: [ self privateSelect: aMonotoneSelection from to: aMonotoneSelection to ] ].
 	
-	selection ifNotEmpty: [ self notifyCursorRemoved: self cursor ]
+	"now that the editor selection is up to date, keep one cursor per selection"
+	editor hasMultipleCursors ifTrue: [
+		editor navigator
+			withMergingWithinSelection;
+			apply ].
+	selection ifNotEmpty: [ editor cursors do: [ :eachCursor | self notifyCursorRemoved: eachCursor ] ]
 	
 	" do not send updateCursors to self here otherwise, navigator moveUp is broken " 
 ]
diff --git a/src/Album/AlbTextEditorShowCursorRequest.class.st b/src/Album/AlbTextEditorShowCursorRequest.class.st
index ef410fe..672c885 100644
--- a/src/Album/AlbTextEditorShowCursorRequest.class.st
+++ b/src/Album/AlbTextEditorShowCursorRequest.class.st
@@ -3,7 +3,8 @@ Class {
 	#superclass : #AlbTextEditorRequest,
 	#instVars : [
 		'cursorPosition',
-		'hasFocus'
+		'hasFocus',
+		'isPrimary'
 	],
 	#category : #'Album-UI-Requests'
 }
@@ -34,3 +35,15 @@ AlbTextEditorShowCursorRequest >> hasFocus [
 AlbTextEditorShowCursorRequest >> hasFocus: anObject [
 	hasFocus := anObject
 ]
+
+{ #category : #accessing }
+AlbTextEditorShowCursorRequest >> isPrimary [
+
+	^ isPrimary ifNil: [ true ]
+]
+
+{ #category : #accessing }
+AlbTextEditorShowCursorRequest >> isPrimary: aBoolean [
+
+	isPrimary := aBoolean
+]
diff --git a/src/Album/AlbTextElement.class.st b/src/Album/AlbTextElement.class.st
index 3cf6872..a54a08f 100644
--- a/src/Album/AlbTextElement.class.st
+++ b/src/Album/AlbTextElement.class.st
@@ -3,7 +3,8 @@ Class {
 	#superclass : #BlTextElement,
 	#instVars : [
 		'cursorElement',
-		'segmentPiece'
+		'segmentPiece',
+		'secondaryCursorElements'
 	],
 	#category : #'Album-UI'
 }
@@ -12,13 +13,41 @@ Class {
 AlbTextElement >> addCursorAt: aTextPosition inEditorElement: anEditorElement [
 
 	<return: #AlbCursorElement>
-	^ self cursorAt: aTextPosition ifFound: #yourself ifNone: [ 
-		  cursorElement ifNil: [ 
-			  cursorElement := anEditorElement cursorElement.
-			  cursorElement removeFromParent.
-			  self addChild: cursorElement ].
-		  cursorElement textPosition: aTextPosition.
-		  cursorElement ]
+	^ self addCursorAt: aTextPosition inEditorElement: anEditorElement primary: true
+]
+
+{ #category : #cursor }
+AlbTextElement >> addCursorAt: aTextPosition inEditorElement: anEditorElement primary: isPrimary [
+	"The primary cursor uses the unique cursor element of the editor element, secondary ones get their own element"
+
+	<return: #AlbCursorElement>
+	| aBackground aCursorElement |
+	isPrimary ifTrue: [
+		cursorElement ifNil: [
+			cursorElement := anEditorElement cursorElement.
+			cursorElement removeFromParent.
+			self addChild: cursorElement ].
+		cursorElement textPosition: aTextPosition.
+		^ cursorElement ].
+	self secondaryCursorElements
+		detect: [ :each | each textPosition = aTextPosition ]
+		ifFound: [ :anExisting | ^ anExisting ].
+	aBackground := anEditorElement cursorElement focusedBackground.
+	aCursorElement := AlbCursorElement new
+		focusedBackground: aBackground;
+		textPosition: aTextPosition;
+		yourself.
+	self secondaryCursorElements add: aCursorElement.
+	self addChild: aCursorElement.
+	^ aCursorElement
+]
+
+{ #category : #cursor }
+AlbTextElement >> allCursorElements [
+
+	^ cursorElement
+		ifNil: [ self secondaryCursorElements asArray ]
+		ifNotNil: [ (Array with: cursorElement) , self secondaryCursorElements asArray ]
 ]
 
 { #category : #'cursor - asserting' }
@@ -39,10 +68,12 @@ AlbTextElement >> assertCursorPosition: anIndex [
 { #category : #'cursor - accessing' }
 AlbTextElement >> cursorAt: aTextPosition ifFound: aFoundBlock ifNone: aNoneBlock [
 
-	cursorElement ifNil: [ ^ aNoneBlock value ].
-	cursorElement textPosition = aTextPosition ifFalse: [ ^ aNoneBlock value ].
-
-	^ aFoundBlock value: cursorElement
+	(cursorElement notNil and: [ cursorElement textPosition = aTextPosition ])
+		ifTrue: [ ^ aFoundBlock value: cursorElement ].
+	^ self secondaryCursorElements
+		detect: [ :each | each textPosition = aTextPosition ]
+		ifFound: aFoundBlock
+		ifNone: aNoneBlock
 ]
 
 { #category : #initialization }
@@ -56,7 +87,7 @@ AlbTextElement >> defaultMinWidth [
 { #category : #'cursor - accessing' }
 AlbTextElement >> hasCursor [
 
-	^ cursorElement notNil
+	^ cursorElement notNil or: [ self secondaryCursorElements notEmpty ]
 ]
 
 { #category : #'cursor - accessing' }
@@ -72,8 +103,8 @@ AlbTextElement >> hasCursorAt: aTextPosition [
 
 { #category : #'cursor - management' }
 AlbTextElement >> hideCursor [
-	cursorElement ifNil: [ ^self ].
-	cursorElement visibility: BlVisibility gone
+
+	self allCursorElements do: [ :each | each visibility: BlVisibility gone ]
 ]
 
 { #category : #initialization }
@@ -92,21 +123,24 @@ AlbTextElement >> initializeMeasurement [
 
 { #category : #layout }
 AlbTextElement >> layoutCursor: aBounds context: aBlElementBoundsUpdateContext [
-		| cursorPos textPosX maxTextPosX minTextPosX textPos |
-		cursorElement ifNil: [ ^self ].
-		"we make sure that the cursor is within text bounds (we allow to add a cursor outside of the text bounds)"
-		cursorPos := cursorElement textPosition min: self text size max: 0.0.
-		
-		maxTextPosX := ((self measuredWidth - (cursorElement measuredWidth))) max: 0.0.
-		minTextPosX := cursorElement measuredWidth negated.
-		
-		textPosX := (self screenPositionAt: cursorPos) x.
-		textPosX := ((textPosX - (cursorElement measuredWidth // 2)) min: maxTextPosX) max: minTextPosX.
-		textPos := (textPosX max: 0.0) @ self padding top.
-		
-		cursorElement
-			applyLayoutIn: (textPos extent: (cursorElement measuredWidth @ ((cursorElement measuredHeight - self padding height) max: 0.0)))
-			context: aBlElementBoundsUpdateContext
+
+	self allCursorElements do: [ :each | self layoutCursorElement: each context: aBlElementBoundsUpdateContext ]
+]
+
+{ #category : #layout }
+AlbTextElement >> layoutCursorElement: aCursorElement context: aBlElementBoundsUpdateContext [
+
+	| cursorPos textPosX maxTextPosX minTextPosX textPos |
+	"we make sure that the cursor is within text bounds (we allow to add a cursor outside of the text bounds)"
+	cursorPos := aCursorElement textPosition min: self text size max: 0.0.
+	maxTextPosX := self measuredWidth - aCursorElement measuredWidth max: 0.0.
+	minTextPosX := aCursorElement measuredWidth negated.
+	textPosX := (self screenPositionAt: cursorPos) x.
+	textPosX := textPosX - (aCursorElement measuredWidth // 2) min: maxTextPosX max: minTextPosX.
+	textPos := (textPosX max: 0.0) @ self padding top.
+	aCursorElement
+		applyLayoutIn: (textPos extent: aCursorElement measuredWidth @ (aCursorElement measuredHeight - self padding height max: 0.0))
+		context: aBlElementBoundsUpdateContext
 ]
 
 { #category : #accessing }
@@ -131,15 +165,27 @@ AlbTextElement >> onLayout: aBounds context: aBlElementBoundsUpdateContext [
 
 { #category : #'cursor - management' }
 AlbTextElement >> removeCursorAt: aTextIndex [
-	"Remove cursor at a goven position"
+	"Remove cursor at a given position"
 
-	^ self
-		cursorAt: aTextIndex
-		ifFound: [ :c |
-			cursorElement removeFromParent.
-			cursorElement := nil.
-			c ]
-		ifNone: [ self error: 'Cursor at ', aTextIndex asString, ' does not exist' ]
+	(cursorElement notNil and: [ cursorElement textPosition = aTextIndex ]) ifTrue: [
+		| aRemoved |
+		aRemoved := cursorElement.
+		cursorElement removeFromParent.
+		cursorElement := nil.
+		^ aRemoved ].
+	^ self secondaryCursorElements
+		detect: [ :each | each textPosition = aTextIndex ]
+		ifFound: [ :aSecondary |
+			self secondaryCursorElements remove: aSecondary.
+			aSecondary removeFromParent.
+			aSecondary ]
+		ifNone: [ self error: 'Cursor at ' , aTextIndex asString , ' does not exist' ]
+]
+
+{ #category : #cursor }
+AlbTextElement >> secondaryCursorElements [
+
+	^ secondaryCursorElements ifNil: [ secondaryCursorElements := OrderedCollection new ]
 ]
 
 { #category : #accessing }
@@ -159,8 +205,8 @@ AlbTextElement >> segmentPiece: aSegmentPiece [
 
 { #category : #'cursor - management' }
 AlbTextElement >> showCursor [
-	cursorElement ifNil: [ ^self ].
-	cursorElement visibility: BlVisibility visible
+
+	self allCursorElements do: [ :each | each visibility: BlVisibility visible ]
 ]
 
 { #category : #'text - accessing' }
diff --git a/src/Album/AlbTextWordPieceShowCursorHandler.class.st b/src/Album/AlbTextWordPieceShowCursorHandler.class.st
index 8da3c20..2c280fa 100644
--- a/src/Album/AlbTextWordPieceShowCursorHandler.class.st
+++ b/src/Album/AlbTextWordPieceShowCursorHandler.class.st
@@ -12,12 +12,11 @@ AlbTextWordPieceShowCursorHandler >> eventClass [
 { #category : #'api - event managing' }
 AlbTextWordPieceShowCursorHandler >> handleEvent: anEvent [
 
-	| aCursorElement |
-	aCursorElement := anEvent currentTarget
-		                  addCursorAt: anEvent cursorPosition
-		                  inEditorElement: anEvent editorElement.
-	(anEvent hasFocus and: [ 
-		 anEvent editorElement selection isEmpty ])
+	anEvent currentTarget
+		addCursorAt: anEvent cursorPosition
+		inEditorElement: anEvent editorElement
+		primary: anEvent isPrimary.
+	(anEvent hasFocus and: [ anEvent editorElement selection isEmpty ])
 		ifTrue: [ anEvent currentTarget showCursor ]
 		ifFalse: [ anEvent currentTarget hideCursor ]
 ]