開発者のためのRectangle:実際に使えるIDE・ターミナル・ブラウザのレイアウト

開発作業の大部分は、同じ3つか4つのウィンドウの間を行き来することで成り立っている。エディタやIDE、ターミナル、ドキュメントや実行中のアプリを表示するブラウザ、そして時には無視しようとしているメッセージアプリだ。Rectangle appの標準ショートカットセットは、無料アプリに最初から入っているもの以外何も必要とせずに、そのローテーションにきれいに対応する。ここでは、知っておく価値のあるレイアウトと、開発者向けツールで具体的に発生する問題を扱う。

単一モニター:2つのウィンドウ

もっとも単純で、もっともよくあるケースだ。もっとも見る頻度の高いほうをエディタに、もう一方をターミナルやドキュメントに割り当てる。

• ⌃⌥← — エディタを左半分へ
• ⌃⌥→ — ターミナルやブラウザを右半分へ

エディタにとって50/50の分割が狭く感じる場合(13〜14インチの画面では、コードエディタがターミナルよりも横幅を必要とするため、よくある不満だ)、まったく別のレイアウトに切り替えるのではなく、⌃⌥=(拡大)を数回押して片側を大きくするといい。組み込みの「60/40の半分」というアクションは存在しないため、すでに半分に分割されたウィンドウに対して拡大・縮小を使うのが、それに近づける方法になる。

単一モニター:3つのウィンドウ

ここで、半分よりも3分の1が本領を発揮する。理にかなった分割の一例:

• ⌃⌥E(最初の3分の2)— エディタ。コードはターミナルよりも横幅の恩恵を受けやすいため
• ⌃⌥G(最後の3分の1)— ターミナル

これにより、エディタが画面の3分の2を、ターミナルが3分の1を占めることになり、どちらも仕切り線をドラッグすることなくキーボードだけで到達できる。代わりにほぼ均等な3列にしたい場合は、⌃⌥D(最初の3分の1)でウィンドウを巡回させる。同じウィンドウでもう一度押すと中央の3分の1に、さらに押すと最後の3分の1に切り替わるので、エディタ・ターミナル・ブラウザをそれぞれ3つの位置に個別に配置すればいい。

2台のモニター:開発者によくある構成

ノートパソコンに外部ディスプレイをつないでいる場合、典型的な分割はこうなる。

• エディタを外部ディスプレイで最大化(⌃⌥↩)する。もっとも大きく鮮明な画面には、1日中見つめるものをふさわしく配置する。
• エディタの隣にターミナルを表示したいなら、外部ディスプレイの半分か3分の1に置く。外部ディスプレイを1つのアプリ専用にしたいなら、⌃⌥⌘←でノートパソコンの画面に移動させる。
• ブラウザやドキュメントはノートパソコンの画面に置き、最大化するか、メッセージアプリと半分ずつに分ける。

どのアプリをどの画面に置くかを頻繁に入れ替える場合、たとえばノートパソコンの画面を投影しながら外部ディスプレイにメモを残しておくような場合、次のディスプレイと前のディスプレイを使えば、ドラッグし直すことなくアクティブなウィンドウを移動できる。この操作が指の記憶になれば、手作業でドラッグするより速い。

開発者向けツールに特有の、既知の摩擦ポイント

ターミナル系アプリと文字幅単位のサイズ変更。 iTerm2はデフォルトでは、任意のピクセル単位ではなく文字幅の整数倍単位でしかサイズを変更しない。そのため、Rectangle macが計算した半分や3分の1のサイズが、通常のGUIアプリで得られるものからわずかにずれることがある。文書化されている修正方法は次の通りだ。

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

実行後はiTerm2を再起動する。Rectangle app自身のメンテナーによれば、Apple純正のTerminal.appも同じ丸め誤差の挙動を示すが、現時点で同等の修正方法は文書化されていない。ピクセル単位で正確なターミナルサイズにこだわりたいなら、この設定を適用したiTerm2のほうが、Terminal.appよりも予測しやすい挙動になる。

独自のキーボードショートカットを持つIDE。 VS CodeやJetBrains系のIDE、その他似たようなツールは、パネル間の移動やリファクタリング用のショートカットなど、自分たちのコマンドにControl + Optionの組み合わせをよく使っており、Rectangle appの標準設定と衝突することがある。Rectangle appをグローバルに再割り当てするのではなく、そのIDEに対してだけアプリを無視を使うといい。IDEをアクティブにし、Rectangleのメニューを開いて「アプリを無視」を選ぶ。これにより、そのIDEが最前面にある間だけRectangleのショートカットが登録解除され、IDE自身のキー割り当てが通常通り機能する。別のアプリに切り替えれば、Rectangleのショートカットは自動的に元に戻る。

フルスクリーンモードは、ウィンドウの本質を変えてしまう。 エディタやターミナルが、通常の最大化されたウィンドウとしてではなく、macOSネイティブのフルスクリーン(専用のスペース)として動作している場合、Rectangleのディスプレイ移動やサイズ変更の操作は、通常のウィンドウモードのアプリに対するようには適用されない。フルスクリーンアプリは、普通の移動可能なウィンドウではないからだ。Rectangleに管理させたいアプリは、ウィンドウモードのままにしておこう。

レイアウトを手作業ではなくスクリプトで組む

RectangleはURLスキームを公開しているため、毎朝4回別々にキーを押す代わりに、決まった日々のレイアウトを1つのスクリプトにまとめてしまえる。

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

それぞれのブロックはアプリをアクティブにし、そのアプリが最前面に来るまで少し待ってから、対応するRectangleのアクションを実行する。これをシェルスクリプトとして保存するか、ホットキーで発動するKeyboard Maestroのマクロに組み込めば、「自分のコーディング用レイアウトを整える」という作業が、4回ではなく1回のキー入力で済むようになる。ただし、これは手作業で組み立てる必要があり、どのディスプレイが接続されているかに応じて自動的に切り替わるわけではない。ディスプレイの接続をトリガーにした自動化は、無料版のスクリプトできれいに再現できるものではなく、Rectangle Proに組み込まれた専用機能だ。

クイックリファレンス

レイアウト	ショートカット
エディタ+ターミナル、単一モニター	⌃⌥← / ⌃⌥→
エディタ+ターミナル、非対称の分割	⌃⌥E(エディタ)/ ⌃⌥G(ターミナル)
エディタ+ターミナル+ブラウザ、3列	⌃⌥D、繰り返し押して巡回
エディタを2台目のディスプレイへ	⌃⌥⌘→ の後に ⌃⌥↩
IDE自身のショートカットを無視する	IDEをアクティブに → Rectangleメニュー → アプリを無視

Rectangle per sviluppatori: layout per IDE, terminale e browser che funzionano

Gran parte del lavoro di sviluppo ruota intorno alle stesse tre o quattro finestre: un editor o un IDE, un terminale, un browser per la documentazione o un’app in esecuzione, e a volte un’app di messaggistica che si cerca di ignorare. Il set di scorciatoie predefinito di Rectangle app si adatta perfettamente a questa rotazione, senza bisogno di nulla di più di quello che offre già l’app gratuita. Qui trovi i layout che vale la pena conoscere e i problemi specifici che emergono con gli strumenti di sviluppo.

Un solo monitor: due finestre

Il caso più semplice e più comune. L’editor occupa la metà che guardi di più; il terminale o la documentazione l’altra:

• ⌃⌥← — l’editor nella metà sinistra
• ⌃⌥→ — il terminale o il browser nella metà destra

Se la divisione 50/50 risulta stretta per l’editor (una lamentela comune su uno schermo da 13-14 pollici, dove un editor di codice vuole più spazio orizzontale di un terminale), ingrandisci un lato un paio di volte con ⌃⌥= (Ingrandisci) invece di passare a un layout completamente diverso. Non esiste un’azione integrata per “metà 60/40”; usare Ingrandisci/Rimpicciolisci su una finestra già divisa a metà è il modo per avvicinarsi a quel risultato.

Un solo monitor: tre finestre

È qui che i terzi si guadagnano il loro posto rispetto alle metà. Una divisione ragionevole:

• ⌃⌥E (primi due terzi) — l’editor, dato che il codice beneficia della larghezza più di un terminale
• ⌃⌥G (ultimo terzo) — il terminale

Questo dà all’editor due terzi dello schermo e al terminale un terzo, entrambi raggiungibili da tastiera senza trascinare alcun divisore. Se preferisci tre colonne all’incirca uguali, fai scorrere una finestra con ⌃⌥D (primo terzo); premerlo di nuovo sulla stessa finestra passa al terzo centrale, poi all’ultimo terzo, e posiziona editor, terminale e browser ciascuno in una delle tre posizioni.

Due monitor: la configurazione tipica dello sviluppatore

Con un display esterno collegato a un portatile, una divisione tipica:

• Editor massimizzato (⌃⌥↩) sul display esterno: lo schermo più grande e nitido merita ciò che guardi tutto il giorno.
• Terminale in metà o un terzo del display esterno se vuoi vederlo accanto all’editor, oppure spostato sullo schermo del portatile con ⌃⌥⌘← se preferisci riservare il display esterno a una sola app.
• Browser o documentazione sullo schermo del portatile, massimizzato o diviso a metà con un’app di messaggistica.

Se cambi spesso quale app si trova su quale schermo, ad esempio quando presenti lo schermo del portatile mantenendo appunti sul display esterno, Display successivo e Display precedente spostano la finestra attiva senza doverla trascinare di nuovo, il che è più veloce di un trascinamento manuale una volta acquisita la memoria muscolare.

Punti di attrito noti specifici per gli strumenti di sviluppo

App di terminale e ridimensionamento per larghezza di carattere. Per impostazione predefinita, iTerm2 si ridimensiona solo a incrementi di intere larghezze di carattere invece che in pixel arbitrari, il che significa che la metà o il terzo calcolato da Rectangle mac può risultare leggermente diverso da quello che otterresti con un’app grafica normale. La correzione documentata:

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

Riavvia iTerm2 dopo averlo eseguito. Il Terminale di Apple stesso presenta lo stesso comportamento di arrotondamento senza che sia attualmente documentata una correzione equivalente, secondo lo stesso maintainer di Rectangle app; se per te conta avere dimensioni del terminale precise al pixel, iTerm2 con questa impostazione applicata si comporta in modo più prevedibile rispetto a Terminale.

IDE con proprie scorciatoie da tastiera. VS Code, gli IDE JetBrains e strumenti simili usano spesso combinazioni Control + Opzione per i propri comandi (navigare tra i pannelli, scorciatoie di refactoring), il che può entrare in collisione con le impostazioni predefinite di Rectangle app. Invece di riassegnare Rectangle a livello globale, usa Ignora app specificamente sull’IDE: portalo in primo piano, apri il menu di Rectangle, scegli Ignora app. Le scorciatoie di Rectangle si disattivano allora solo finché quell’IDE è in primo piano, e le combinazioni proprie dell’IDE funzionano normalmente. Passa a un’altra app e le scorciatoie di Rectangle tornano automaticamente.

La modalità schermo intero cambia cosa sia davvero una finestra. Se il tuo editor o terminale funziona in modalità schermo intero nativa di macOS (il proprio Spazio) invece che come una normale finestra massimizzata, le azioni di Rectangle per spostarsi tra display e ridimensionare non si applicano come farebbero con un’app in modalità finestra; le app a schermo intero non sono normali finestre spostabili. Mantieni in modalità finestra le app che vuoi che Rectangle gestisca.

Scriptare un layout invece di ricostruirlo a mano

Dato che Rectangle espone uno schema URL, un layout quotidiano fisso può essere ridotto a un unico script invece di quattro pressioni da tastiera separate ogni mattina:

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

Ogni blocco attiva un’app, attende brevemente che passi in primo piano, poi attiva l’azione Rectangle corrispondente. Salva questo come script di shell oppure collegalo a una macro di Keyboard Maestro attivata da una scorciatoia, e “imposta il mio layout di lavoro” diventa una singola pressione di tasto invece di quattro. Questo va costruito manualmente e non si adatta automaticamente a quale display sia collegato; questo tipo di automazione attivata al collegamento del display è una funzione integrata in Rectangle Pro, non qualcosa che lo scripting del livello gratuito riproduce in modo pulito.

Riferimento rapido

Layout	Scorciatoie
Editor + terminale, un solo monitor	⌃⌥← / ⌃⌥→
Editor + terminale, divisione asimmetrica	⌃⌥E (editor) / ⌃⌥G (terminale)
Editor + terminale + browser, tre colonne	⌃⌥D, scorri con pressioni ripetute
Editor sul secondo display	⌃⌥⌘→ poi ⌃⌥↩
Ignora le scorciatoie proprie dell’IDE	Porta in primo piano l’IDE → menu Rectangle → Ignora app

Rectangle pour développeurs : des dispositions IDE, terminal et navigateur qui fonctionnent

La plupart du travail de développement tourne autour des trois ou quatre mêmes fenêtres : un éditeur ou un IDE, un terminal, un navigateur pour la documentation ou une app en cours d’exécution, et parfois une app de messagerie qu’on essaie d’ignorer. L’ensemble de raccourcis par défaut de Rectangle app s’adapte parfaitement à cette rotation, sans rien de plus que ce que propose déjà l’app gratuite. Voici les dispositions qui valent la peine d’être connues, et les problèmes précis qui surviennent avec les outils de développement.

Un seul écran : deux fenêtres

Le cas le plus simple et le plus courant. L’éditeur prend la moitié que vous regardez le plus ; le terminal ou la documentation prend l’autre :

• ⌃⌥← — l’éditeur dans la moitié gauche
• ⌃⌥→ — le terminal ou le navigateur dans la moitié droite

Si le partage 50/50 semble étroit pour l’éditeur (une plainte courante sur un écran de 13-14 pouces, où un éditeur de code veut plus de largeur qu’un terminal), agrandissez un côté quelques fois avec ⌃⌥= (Agrandir la taille) plutôt que de basculer vers une disposition complètement différente. Il n’existe pas d’action intégrée « moitiés 60/40 » ; utiliser Agrandir/Réduire sur une fenêtre déjà en moitié permet de s’en approcher.

Un seul écran : trois fenêtres

C’est là que les tiers deviennent plus pertinents que les moitiés. Une répartition raisonnable :

• ⌃⌥E (deux premiers tiers) — l’éditeur, car le code profite davantage de la largeur qu’un terminal
• ⌃⌥G (dernier tiers) — le terminal

Cela donne à l’éditeur deux tiers de l’écran et au terminal un tiers, les deux accessibles au clavier sans avoir à glisser un séparateur. Si vous préférez trois colonnes à peu près égales, faites défiler une fenêtre avec ⌃⌥D (premier tiers) ; l’appuyer à nouveau sur la même fenêtre passe au tiers central, puis au dernier tiers, et placez l’éditeur, le terminal, et le navigateur chacun dans l’une des trois positions.

Deux écrans : la configuration classique du développeur

Avec un écran externe connecté à un portable, une répartition typique :

• L’éditeur agrandi (⌃⌥↩) sur l’écran externe, le plus grand écran, le plus net, mérite ce que vous regardez toute la journée.
• Le terminal dans une moitié ou un tiers de l’écran externe si vous voulez le voir à côté de l’éditeur, ou déplacé vers l’écran du portable avec ⌃⌥⌘← si vous préférez réserver l’écran externe à une seule app.
• Le navigateur ou la documentation sur l’écran du portable, agrandi ou partagé en deux avec une app de messagerie.

Si vous échangez fréquemment quelle app se trouve sur quel écran, par exemple en présentant l’écran de votre portable tout en gardant des notes sur l’écran externe, Écran suivant et Écran précédent déplacent la fenêtre active sans avoir à la glisser de nouveau, ce qui va plus vite qu’un glisser manuel une fois que vous avez cette mémoire musculaire.

Points de friction connus propres aux outils de développement

Les apps de terminal et le redimensionnement par largeur de caractère. Par défaut, iTerm2 ne se redimensionne que par incréments de largeurs de caractère entières plutôt qu’en pixels arbitraires, ce qui veut dire que la moitié ou le tiers calculé par Rectangle mac peut se retrouver légèrement décalé par rapport à ce qu’on obtiendrait avec une app graphique classique. Le correctif documenté :

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

Redémarrez iTerm2 après l’avoir exécuté. Le Terminal.app d’Apple lui-même présente le même comportement d’arrondi, sans correctif équivalent actuellement documenté selon le mainteneur même de Rectangle app ; si un dimensionnement de terminal précis au pixel près compte pour vous, iTerm2 avec ce réglage se comporte de façon plus prévisible que Terminal.app.

Les IDE avec leurs propres raccourcis clavier. VS Code, les IDE JetBrains, et des outils similaires utilisent souvent des combinaisons Control + Option pour leurs propres commandes (naviguer entre les panneaux, raccourcis de refactorisation), ce qui peut entrer en collision avec les valeurs par défaut de Rectangle app. Plutôt que de réassigner Rectangle globalement, utilisez Ignorer l’app spécifiquement sur l’IDE : donnez-lui le focus, ouvrez le menu de Rectangle, choisissez Ignorer l’app. Les raccourcis de Rectangle se désenregistrent alors uniquement tant que cet IDE est au premier plan, et les combinaisons propres à l’IDE fonctionnent normalement. Passez à une autre app et les raccourcis de Rectangle reviennent automatiquement.

Le mode plein écran change la nature même d’une fenêtre. Si votre éditeur ou terminal tourne en plein écran natif macOS (son propre Espace) plutôt que comme une fenêtre normale agrandie, les actions de déplacement vers un autre écran et de redimensionnement de Rectangle ne s’appliquent pas comme pour une app en mode fenêtré ; les apps en plein écran ne sont pas des fenêtres déplaçables ordinaires. Gardez en mode fenêtré les apps que vous voulez que Rectangle gère.

Scripter une disposition plutôt que la reconstruire à la main

Comme Rectangle expose un schéma d’URL, une disposition quotidienne fixe peut se réduire à un seul script plutôt qu’à quatre appuis clavier séparés chaque matin :

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

Chaque bloc active une app, attend brièvement qu’elle passe au premier plan, puis déclenche l’action Rectangle correspondante. Enregistrez ça comme script shell ou intégrez-le dans une macro Keyboard Maestro déclenchée par un raccourci, et « installer ma disposition de code » devient une seule pression de touche au lieu de quatre. C’est manuel à construire et ça ne s’adapte pas automatiquement selon l’écran connecté ; ce genre d’automatisation déclenchée à la connexion d’un écran est une fonctionnalité intégrée dans Rectangle Pro plutôt que quelque chose que le scripting du niveau gratuit reproduit proprement.

Repère rapide

Disposition	Raccourcis
Éditeur + terminal, un seul écran	⌃⌥← / ⌃⌥→
Éditeur + terminal, partage inégal	⌃⌥E (éditeur) / ⌃⌥G (terminal)
Éditeur + terminal + navigateur, trois colonnes	⌃⌥D, défiler par appuis répétés
Éditeur sur le second écran	⌃⌥⌘→ puis ⌃⌥↩
Ignorer les raccourcis propres de l’IDE	Focus sur l’IDE → menu Rectangle → Ignorer l’app

Rectangle für Entwickler: IDE-, Terminal- und Browser-Layouts, die funktionieren

Die meisten Entwicklungsarbeiten drehen sich um dieselben drei oder vier Fenster: einen Editor oder eine IDE, ein Terminal, einen Browser für Dokumentation oder eine laufende App, und manchmal eine Messaging-App, die man eigentlich ignorieren will. Rectangle app Standard-Tastenkombinationen passen sauber auf diese Rotation, ganz ohne mehr als das, was die kostenlose App von Haus aus mitbringt. Hier geht es um die Layouts, die sich zu kennen lohnen, und um die konkreten Probleme, die bei Entwickler-Tools auftauchen.

Ein Monitor: zwei Fenster

Der einfachste und häufigste Fall. Der Editor bekommt die Hälfte, auf die du am meisten schaust; Terminal oder Dokumentation die andere:

• ⌃⌥← — Editor auf die linke Hälfte
• ⌃⌥→ — Terminal oder Browser auf die rechte Hälfte

Fühlt sich die 50/50-Aufteilung für den Editor zu eng an (eine häufige Beschwerde bei einem 13-14-Zoll-Bildschirm, wo ein Code-Editor mehr horizontalen Platz braucht als ein Terminal), vergrößere eine Seite ein paarmal mit ⌃⌥= (Vergrößern), statt zu einem völlig anderen Layout zu wechseln. Eine eingebaute „60/40-Hälften”-Aktion gibt es nicht, Vergrößern/Verkleinern bei einem bereits halbierten Fenster ist der Weg, das anzunähern.

Ein Monitor: drei Fenster

Hier verdienen sich Drittel ihren Platz gegenüber Hälften. Eine sinnvolle Aufteilung:

• ⌃⌥E (erste zwei Drittel) — Editor, da Code mehr von Breite profitiert als ein Terminal
• ⌃⌥G (letztes Drittel) — Terminal

Damit bekommt der Editor zwei Drittel des Bildschirms und das Terminal ein Drittel, beides per Tastatur erreichbar, ohne eine Trennlinie zu ziehen. Willst du stattdessen drei ungefähr gleich große Spalten, schalte ein Fenster mit ⌃⌥D (erstes Drittel) durch, erneutes Drücken auf demselben Fenster wechselt zum mittleren Drittel, dann zum letzten Drittel, und platziere Editor, Terminal und Browser einzeln in die drei Positionen.

Zwei Monitore: das übliche Entwickler-Setup

Mit einem externen Display an einem Laptop, eine typische Aufteilung:

• Editor maximiert (⌃⌥↩) auf dem externen Display — der größte, schärfste Bildschirm verdient das, worauf du den ganzen Tag schaust.
• Terminal in einer Hälfte oder einem Drittel des externen Displays, wenn du es neben dem Editor sichtbar haben willst, oder mit ⌃⌥⌘← auf den Laptop-Bildschirm verschoben, wenn du das externe Display lieber für eine App reservieren willst.
• Browser oder Dokumentation auf dem Laptop-Bildschirm, maximiert oder halbiert mit einer Messaging-App.

Wechselst du häufig, welche App auf welchem Bildschirm läuft, etwa wenn du deinen Laptop-Bildschirm präsentierst und dabei Notizen auf dem externen Display behältst, verschieben Nächstes Display und Vorheriges Display das aktive Fenster hinüber, ohne es neu zu ziehen, was schneller geht als ein manuelles Ziehen, sobald sich das Muskelgedächtnis eingestellt hat.

Bekannte Reibungspunkte speziell bei Entwickler-Tools

Terminal-Apps und Größenänderung in Zeichenbreiten. iTerm2 ändert standardmäßig seine Größe nur in Schritten von vollen Zeichenbreiten statt in beliebigen Pixeln, wodurch Rectangle mac berechnete Hälfte oder Drittel leicht von dem abweichen kann, was du bei einer GUI-App bekommen würdest. Die dokumentierte Lösung:

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

Starte iTerm2 danach neu. Apples eigenes Terminal.app zeigt laut Rectangle app eigenem Maintainer dasselbe Rundungsverhalten, ohne dass derzeit eine vergleichbare Lösung dokumentiert ist, ist dir pixelgenaue Terminal-Größe wichtig, verhält sich iTerm2 mit dieser Einstellung vorhersehbarer als Terminal.app.

IDEs mit eigenen Tastenkombinationen. VS Code, JetBrains-IDEs und ähnliche Tools nutzen oft Control + Wahltaste-Kombinationen für eigene Befehle (zwischen Bereichen navigieren, Refactoring-Shortcuts), was mit Rectangle app Standardeinstellungen kollidieren kann. Statt Rectangle global neu zu belegen, nutze App ignorieren gezielt für die IDE: fokussiere sie, öffne das Rectangle-Menü, wähle App ignorieren. Rectangles Tastenkombinationen werden dann nur abgemeldet, solange diese IDE im Vordergrund ist, und die eigenen Belegungen der IDE funktionieren normal. Wechselst du zu einer anderen App, kommen Rectangles Tastenkombinationen automatisch zurück.

Vollbildmodus verändert, was ein Fenster überhaupt ist. Läuft dein Editor oder Terminal im nativen macOS-Vollbild (einem eigenen Space) statt als normal maximiertes Fenster, gelten Rectangles Aktionen zum Verschieben zwischen Displays und zum Ändern der Größe nicht so wie bei einer App im Fenstermodus, Vollbild-Apps sind keine gewöhnlichen, verschiebbaren Fenster. Halte die Apps, die du von Rectangle verwalten lassen willst, im Fenstermodus.

Ein Layout skripten, statt es von Hand neu aufzubauen

Da Rectangle ein URL-Schema bereitstellt, lässt sich ein festes tägliches Layout auf ein einziges Skript reduzieren, statt jeden Morgen vier separate Tastendrücke auszuführen:

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

Jeder Block aktiviert eine App, wartet kurz, bis sie im Vordergrund ist, und löst dann die passende Rectangle-Aktion aus. Speichere das als Shell-Skript oder binde es in ein Keyboard-Maestro-Makro ein, das über eine Tastenkombination ausgelöst wird, und „mein Coding-Layout einrichten” wird zu einem einzigen Tastendruck statt vier. Das musst du manuell bauen, und es passt sich nicht automatisch daran an, welches Display gerade angeschlossen ist, diese Art von Auslösen-beim-Display-Anschluss-Automatisierung ist eine eingebaute Funktion in Rectangle Pro, statt etwas, das sich mit Skripting in der kostenlosen Version sauber nachbauen lässt.

Kurzübersicht

Layout	Tastenkombinationen
Editor + Terminal, ein Monitor	⌃⌥← / ⌃⌥→
Editor + Terminal, ungleiche Aufteilung	⌃⌥E (Editor) / ⌃⌥G (Terminal)
Editor + Terminal + Browser, drei Spalten	⌃⌥D, mit wiederholtem Drücken durchschalten
Editor auf zweitem Display	⌃⌥⌘→ dann ⌃⌥↩
Eigene Tastenkombinationen der IDE ignorieren	IDE fokussieren → Rectangle-Menü → App ignorieren

Rectangle para desarrolladores: diseños de IDE, terminal y navegador que funcionan

La mayor parte del trabajo de desarrollo gira en torno a las mismas tres o cuatro ventanas: un editor o IDE, una terminal, un navegador para la documentación o una app en ejecución, y a veces una app de mensajería que intentas ignorar. El conjunto de atajos por defecto de Rectangle app encaja perfectamente con esa rotación sin necesitar nada más que lo que trae de fábrica la app gratuita. Aquí se repasan los diseños que merece la pena conocer y los problemas concretos que surgen con las herramientas de desarrollo.

Un solo monitor: dos ventanas

El caso más simple y habitual. El editor ocupa la mitad a la que más miras; la terminal o la documentación, la otra:

• ⌃⌥← — el editor a la mitad izquierda
• ⌃⌥→ — la terminal o el navegador a la mitad derecha

Si el reparto 50/50 se siente apretado para el editor (una queja habitual en una pantalla de 13-14 pulgadas, donde un editor de código quiere más espacio horizontal que una terminal), agranda un lado un par de veces con ⌃⌥= (Aumentar) en lugar de cambiar a un diseño completamente distinto. No existe una acción integrada de “mitades 60/40”; usar Aumentar/Reducir sobre una ventana ya dividida a la mitad es la forma de aproximarse a eso.

Un solo monitor: tres ventanas

Aquí es donde los tercios se ganan su sitio frente a las mitades. Un reparto razonable:

• ⌃⌥E (primeros dos tercios) — el editor, ya que el código se beneficia más del ancho que una terminal
• ⌃⌥G (último tercio) — la terminal

Eso le da al editor dos tercios de la pantalla y a la terminal un tercio, ambos accesibles desde el teclado sin arrastrar ningún divisor. Si prefieres tres columnas más o menos iguales, hazle un ciclo a una ventana con ⌃⌥D (primer tercio); pulsarlo de nuevo sobre la misma ventana pasa al tercio central, luego al último tercio, y coloca el editor, la terminal y el navegador cada uno en una de las tres posiciones.

Dos monitores: la configuración habitual de un desarrollador

Con una pantalla externa conectada a un portátil, un reparto típico:

• El editor maximizado (⌃⌥↩) en la pantalla externa; la pantalla más grande y nítida se merece aquello que miras todo el día.
• La terminal en una mitad o tercio de la pantalla externa si quieres verla junto al editor, o movida a la pantalla del portátil con ⌃⌥⌘← si prefieres reservar la pantalla externa para una sola app.
• El navegador o la documentación en la pantalla del portátil, maximizado o partido a la mitad con una app de mensajería.

Si cambias con frecuencia qué app va en qué pantalla, por ejemplo, cuando presentas la pantalla de tu portátil mientras mantienes notas en la pantalla externa, Pantalla siguiente y Pantalla anterior mueven la ventana activa sin necesidad de volver a arrastrarla, algo más rápido que un arrastre manual una vez que ya tienes la memoria muscular.

Puntos de fricción conocidos específicos de herramientas de desarrollo

Apps de terminal y el redimensionado por ancho de carácter. Por defecto, iTerm2 solo cambia de tamaño en incrementos de anchos de carácter completos en lugar de píxeles arbitrarios, lo que significa que la mitad o el tercio calculado por Rectangle mac puede quedar ligeramente desviado de lo que obtendrías con una app gráfica normal. La solución documentada:

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

Reinicia iTerm2 después de ejecutarlo. La propia Terminal.app de Apple tiene el mismo comportamiento de redondeo sin que exista actualmente una solución equivalente documentada, según el propio mantenedor de Rectangle app; si te importa que el tamaño de la terminal sea preciso al píxel, iTerm2 con este ajuste aplicado se comporta de forma más predecible que Terminal.app.

IDEs con sus propios atajos de teclado. VS Code, los IDE de JetBrains y herramientas parecidas suelen usar combinaciones de Control + Opción para sus propios comandos (navegar entre paneles, atajos de refactorización), lo que puede chocar con los valores por defecto de Rectangle app. En lugar de reasignar Rectangle de forma global, usa Ignorar app específicamente para el IDE: dale el foco, abre el menú de Rectangle, elige Ignorar app. Los atajos de Rectangle se desactivan entonces solo mientras ese IDE está en primer plano, y las combinaciones propias del IDE funcionan con normalidad. Cambia a otra app y los atajos de Rectangle vuelven automáticamente.

El modo de pantalla completa cambia lo que es una ventana. Si tu editor o terminal se ejecuta en pantalla completa nativa de macOS (en su propio Espacio) en lugar de como una ventana normal maximizada, las acciones de Rectangle para mover a otra pantalla y redimensionar no se aplican de la misma forma que a una app en modo ventana; las apps a pantalla completa no son ventanas móviles normales. Mantén en modo ventana las apps que quieras que gestione Rectangle.

Automatizar un diseño con un script en lugar de reconstruirlo a mano

Como Rectangle expone un esquema de URL, un diseño diario fijo se puede reducir a un único script en lugar de cuatro pulsaciones de teclado distintas cada mañana:

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

Cada bloque activa una app, espera brevemente a que pase a primer plano, y luego dispara la acción de Rectangle correspondiente. Guarda esto como un script de shell o conéctalo a una macro de Keyboard Maestro activada por una tecla de acceso rápido, y “montar mi diseño de programación” se convierte en una sola pulsación en lugar de cuatro. Esto hay que construirlo a mano y no se adapta automáticamente a qué monitor esté conectado; ese tipo de automatización que se activa al conectar una pantalla es una función integrada en Rectangle Pro, no algo que el scripting del nivel gratuito reproduzca de forma limpia.

Referencia rápida

Diseño	Atajos
Editor + terminal, un solo monitor	⌃⌥← / ⌃⌥→
Editor + terminal, reparto desigual	⌃⌥E (editor) / ⌃⌥G (terminal)
Editor + terminal + navegador, tres columnas	⌃⌥D, ciclar con pulsaciones repetidas
Editor en la segunda pantalla	⌃⌥⌘→ y luego ⌃⌥↩
Ignorar los atajos propios del IDE	Dar foco al IDE → menú de Rectangle → Ignorar app

Rectangle for Developers: IDE, Terminal, and Browser Layouts That Work

Most development work rotates through the same three or four windows: an editor or IDE, a terminal, a browser for documentation or a running app, and sometimes a messaging app you’re trying to ignore. Rectangle app‘s default shortcut set maps cleanly onto that rotation without needing anything beyond what ships in the free app. This covers the layouts worth knowing and the specific issues that come up with developer tools.

Single monitor: two windows

The simplest and most common case. Editor takes the half you look at most; terminal or docs take the other:

• ⌃⌥← — editor to the left half
• ⌃⌥→ — terminal or browser to the right half

If the 50/50 split feels cramped for the editor (a common complaint on a 13-14″ screen where a code editor wants more horizontal room than a terminal does), grow one side with ⌃⌥= (Make Larger) a couple of times rather than switching to a completely different layout. There’s no built-in “60/40 halves” action — Make Larger/Make Smaller on an already-halved window is the way to approximate it.

Single monitor: three windows

This is where thirds earn their place over halves. A reasonable split:

• ⌃⌥E (first two-thirds) — editor, since code benefits from width more than a terminal does
• ⌃⌥G (last third) — terminal

That gives the editor two-thirds of the screen and the terminal one-third, both reachable from the keyboard without dragging a divider. If you want three roughly-equal columns instead, cycle a window through ⌃⌥D (first third) — pressing it again on the same window cycles to center-third, then last-third — and place editor, terminal, and browser into the three positions individually.

Two monitors: the common developer setup

With an external display connected to a laptop, a typical split:

• Editor maximized (⌃⌥↩) on the external display — the biggest, sharpest screen deserves the thing you look at all day.
• Terminal in a half or third of the external display if you want it visible alongside the editor, or moved to the laptop screen with ⌃⌥⌘← if you’d rather keep the external display to one app.
• Browser or documentation on the laptop screen, maximized or halved with a messaging app.

If you frequently swap which app is on which screen — say, presenting your laptop screen while keeping notes on the external display — Next Display and Previous Display move the active window over without re-dragging it, which is faster than a manual drag once you’ve built the muscle memory.

Known friction points for developer tools specifically

Terminal apps and character-width resizing. iTerm2, by default, only resizes in increments of full character widths rather than arbitrary pixels, which means Rectangle mac‘s calculated half or third can land slightly off from what you’d get with a GUI app. The documented fix:

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

Restart iTerm2 after running it. Apple’s own Terminal.app has the same rounding behavior with no equivalent fix currently documented, per Rectangle app‘s own maintainer — if precise pixel-perfect terminal sizing matters to you, iTerm2 with this setting applied behaves more predictably than Terminal.app.

IDEs with their own keyboard shortcuts. VS Code, JetBrains IDEs, and similar tools often use Control + Option combinations for their own commands (navigating panes, refactoring shortcuts), which can collide with Rectangle app‘s defaults. Rather than remapping Rectangle globally, use Ignore app on the IDE specifically: focus it, open the Rectangle menu, choose Ignore app. Rectangle’s shortcuts then unregister only while that IDE is frontmost, and the IDE’s own bindings work normally. Switch to another app and Rectangle’s shortcuts come back automatically.

Full-screen mode changes what a window even is. If your editor or terminal runs in native macOS full-screen (its own Space) rather than as a normal maximized window, Rectangle’s move-to-display and resize actions don’t apply the way they do to a windowed app — full-screen apps aren’t ordinary movable windows. Keep the apps you want Rectangle managing in windowed mode.

Scripting a layout instead of rebuilding it by hand

Because Rectangle exposes a URL scheme, a fixed daily layout can be reduced to a single script rather than four separate keyboard presses every morning:

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

Each block activates an app, waits briefly for it to become frontmost, then fires the matching Rectangle action. Save this as a shell script or wire it into a Keyboard Maestro macro triggered by a hotkey, and “set up my coding layout” becomes one keypress instead of four. This is manual to build and won’t adapt automatically to which monitor is connected — that kind of trigger-on-display-connect automation is a built-in feature in Rectangle Pro rather than something free-tier scripting replicates cleanly.

Quick reference

Layout	Shortcuts
Editor + terminal, single monitor	⌃⌥← / ⌃⌥→
Editor + terminal, uneven split	⌃⌥E (editor) / ⌃⌥G (terminal)
Editor + terminal + browser, three columns	⌃⌥D, cycle with repeated presses
Editor on second display	⌃⌥⌘→ then ⌃⌥↩
Ignore IDE’s own shortcuts	Focus IDE → Rectangle menu → Ignore app

Rectangle voor developers: IDE-, terminal- en browserindelingen die werken

Het meeste ontwikkelwerk draait om dezelfde drie of vier vensters: een editor of IDE, een terminal, een browser voor documentatie of een draaiende app, en soms een berichten-app die je probeert te negeren. Rectangle app standaard sneltoetsen sluiten naadloos aan op die rotatie, zonder dat je meer nodig hebt dan wat de gratis app standaard biedt. Dit behandelt de indelingen die de moeite waard zijn om te kennen, en de specifieke problemen die opduiken bij ontwikkelaarstools.

Eén scherm: twee vensters

Het eenvoudigste en meest voorkomende geval. De editor krijgt de helft waar je het meest naar kijkt; de terminal of documentatie de andere:

• ⌃⌥← — editor naar de linkerhelft
• ⌃⌥→ — terminal of browser naar de rechterhelft

Voelt de 50/50-verdeling krap aan voor de editor (een veelgehoorde klacht op een 13-14-inch scherm, waar een code-editor meer horizontale ruimte wil dan een terminal), maak dan een van de kanten een paar keer groter met ⌃⌥= (Groter maken) in plaats van naar een compleet andere indeling over te schakelen. Er is geen ingebouwde “60/40-helften”-actie; Groter/Kleiner maken toepassen op een al gehalveerd venster is de manier om dat te benaderen.

Eén scherm: drie vensters

Hier verdienen derden hun plaats ten opzichte van helften. Een redelijke verdeling:

• ⌃⌥E (eerste twee derde) — editor, aangezien code meer baat heeft bij breedte dan een terminal
• ⌃⌥G (laatste derde) — terminal

Dat geeft de editor tweederde van het scherm en de terminal een derde, beide bereikbaar vanaf het toetsenbord zonder een scheidingslijn te slepen. Wil je liever drie ongeveer gelijke kolommen, schakel dan een venster door met ⌃⌥D (eerste derde), nogmaals indrukken op hetzelfde venster schakelt naar het middelste derde, dan naar het laatste derde, en plaats editor, terminal en browser elk op een van de drie posities.

Twee schermen: de gangbare developer-opstelling

Met een extern scherm aangesloten op een laptop, een typische verdeling:

• Editor gemaximaliseerd (⌃⌥↩) op het externe scherm, het grootste, scherpste scherm verdient waar je de hele dag naar kijkt.
• Terminal in een helft of derde van het externe scherm als je hem naast de editor zichtbaar wilt hebben, of verplaatst naar het laptopscherm met ⌃⌥⌘← als je het externe scherm liever aan één app wijdt.
• Browser of documentatie op het laptopscherm, gemaximaliseerd of gehalveerd met een berichten-app.

Wissel je vaak welke app op welk scherm staat, bijvoorbeeld wanneer je je laptopscherm presenteert terwijl je notities op het externe scherm bijhoudt, dan verplaatsen Volgend scherm en Vorig scherm het actieve venster zonder het opnieuw te hoeven slepen, wat sneller gaat dan handmatig slepen zodra je dat spiergeheugen hebt opgebouwd.

Bekende wrijvingspunten specifiek voor ontwikkelaarstools

Terminal-apps en formaataanpassing per tekenbreedte. Standaard verandert iTerm2 alleen van formaat in stappen van hele tekenbreedtes in plaats van willekeurige pixels, wat betekent dat de door Rectangle mac berekende helft of derde net iets kan afwijken van wat je bij een gewone GUI-app zou krijgen. De gedocumenteerde oplossing:

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

Herstart iTerm2 na het uitvoeren hiervan. Apples eigen Terminal.app vertoont volgens Rectangle app eigen maintainer hetzelfde afrondingsgedrag, zonder dat daar momenteel een gelijkwaardige oplossing voor is gedocumenteerd; is pixelnauwkeurig terminalformaat belangrijk voor jou, dan gedraagt iTerm2 met deze instelling zich voorspelbaarder dan Terminal.app.

IDE’s met eigen sneltoetsen. VS Code, JetBrains-IDE’s en vergelijkbare tools gebruiken vaak Control + Option-combinaties voor hun eigen commando’s (tussen panelen navigeren, refactor-sneltoetsen), wat kan botsen met Rectangle app standaardinstellingen. Wijs Rectangle niet globaal opnieuw toe, maar gebruik App negeren specifiek voor de IDE: geef hem focus, open het Rectangle-menu, kies App negeren. Rectangles sneltoetsen worden dan alleen afgemeld zolang die IDE op de voorgrond staat, en de eigen toewijzingen van de IDE werken gewoon. Schakel naar een andere app en Rectangles sneltoetsen komen automatisch terug.

Volledig-schermmodus verandert wat een venster überhaupt is. Draait je editor of terminal in native macOS-volledig-scherm (zijn eigen Space) in plaats van als een normaal gemaximaliseerd venster, dan gelden Rectangles verplaats-naar-scherm- en formaataanpassingsacties niet zoals bij een app in vensterweergave, volledig-scherm-apps zijn geen gewone, verplaatsbare vensters. Houd de apps die je door Rectangle wilt laten beheren in vensterweergave.

Een indeling scripten in plaats van hem handmatig opnieuw op te bouwen

Omdat Rectangle een URL-schema beschikbaar stelt, kan een vaste dagelijkse indeling worden teruggebracht tot één enkel script in plaats van elke ochtend vier aparte toetsaanslagen:

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

Elk blok activeert een app, wacht even tot hij naar voren komt, en activeert dan de bijbehorende Rectangle-actie. Sla dit op als shellscript of koppel het aan een Keyboard Maestro-macro die door een sneltoets wordt geactiveerd, en “mijn codeer-indeling instellen” wordt één toetsaanslag in plaats van vier. Dit moet je handmatig bouwen en het past zich niet automatisch aan welk scherm er is aangesloten, dat soort activeren-bij-schermverbinding-automatisering is een ingebouwde functie in Rectangle Pro, en niet iets wat scripting in de gratis versie netjes nabootst.

Snel overzicht

Indeling	Sneltoetsen
Editor + terminal, één scherm	⌃⌥← / ⌃⌥→
Editor + terminal, ongelijke verdeling	⌃⌥E (editor) / ⌃⌥G (terminal)
Editor + terminal + browser, drie kolommen	⌃⌥D, doorschakelen met herhaald indrukken
Editor op tweede scherm	⌃⌥⌘→ dan ⌃⌥↩
Eigen sneltoetsen van IDE negeren	IDE focussen → Rectangle-menu → App negeren

Rectangle para desenvolvedores: layouts de IDE, terminal e navegador que funcionam

A maior parte do trabalho de desenvolvimento gira em torno das mesmas três ou quatro janelas: um editor ou IDE, um terminal, um navegador para documentação ou um app em execução, e às vezes um app de mensagens que você tenta ignorar. O conjunto de atalhos padrão do Rectangle app se encaixa perfeitamente nessa rotina, sem precisar de nada além do que já vem no app gratuito. Aqui estão os layouts que vale a pena conhecer e os problemas específicos que aparecem com ferramentas de desenvolvimento.

Um monitor: duas janelas

O caso mais simples e mais comum. O editor fica com a metade que você mais olha; o terminal ou a documentação fica com a outra:

• ⌃⌥← — editor na metade esquerda
• ⌃⌥→ — terminal ou navegador na metade direita

Se a divisão 50/50 parecer apertada para o editor (uma reclamação comum em telas de 13-14 polegadas, onde um editor de código quer mais espaço horizontal do que um terminal), aumente um lado algumas vezes com ⌃⌥= (Aumentar) em vez de trocar para um layout completamente diferente. Não existe uma ação embutida de “metades 60/40” — usar Aumentar/Diminuir em uma janela já dividida ao meio é a forma de chegar perto disso.

Um monitor: três janelas

É aqui que os terços ganham espaço em relação às metades. Uma divisão razoável:

• ⌃⌥E (primeiros dois terços) — editor, já que código se beneficia mais de largura do que um terminal
• ⌃⌥G (último terço) — terminal

Isso dá ao editor dois terços da tela e ao terminal um terço, ambos acessíveis pelo teclado sem arrastar nenhum divisor. Se preferir três colunas mais ou menos iguais, circule uma janela com ⌃⌥D (primeiro terço) — pressionar de novo na mesma janela alterna para o terço central, depois para o último terço — e coloque editor, terminal e navegador cada um em uma das três posições.

Dois monitores: a configuração comum de desenvolvedor

Com um monitor externo conectado a um notebook, uma divisão típica:

• Editor maximizado (⌃⌥↩) no monitor externo — a tela maior e mais nítida merece o que você olha o dia todo.
• Terminal em metade ou um terço do monitor externo se você quiser vê-lo ao lado do editor, ou movido para a tela do notebook com ⌃⌥⌘← se preferir reservar o monitor externo para um único app.
• Navegador ou documentação na tela do notebook, maximizado ou dividido ao meio com um app de mensagens.

Se você troca com frequência qual app fica em qual tela — digamos, apresentando a tela do notebook enquanto mantém anotações no monitor externo — Próximo Monitor e Monitor Anterior movem a janela ativa sem você precisar arrastá-la de novo, o que é mais rápido do que um arrasto manual depois que você já tem essa memória muscular.

Pontos de atrito conhecidos, específicos para ferramentas de desenvolvimento

Apps de terminal e redimensionamento por largura de caractere. Por padrão, o iTerm2 só redimensiona em incrementos de larguras de caractere inteiras, em vez de pixels arbitrários, o que significa que a metade ou o terço calculado pelo Rectangle mac pode ficar um pouco diferente do que você teria com um app gráfico comum. A correção documentada:

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

Reinicie o iTerm2 depois de executar isso. O próprio Terminal.app da Apple tem o mesmo comportamento de arredondamento, sem uma correção equivalente documentada no momento, segundo o próprio mantenedor do Rectangle app — se um dimensionamento de terminal preciso no pixel importa para você, o iTerm2 com essa configuração aplicada se comporta de forma mais previsível do que o Terminal.app.

IDEs com atalhos de teclado próprios. O VS Code, os IDEs da JetBrains, e ferramentas parecidas costumam usar combinações de Control + Option para seus próprios comandos (navegar entre painéis, atalhos de refatoração), o que pode colidir com os padrões do Rectangle app. Em vez de remapear o Rectangle globalmente, use Ignorar app especificamente para o IDE: dê foco a ele, abra o menu do Rectangle, escolha Ignorar app. Os atalhos do Rectangle então ficam desregistrados só enquanto aquele IDE está em primeiro plano, e as combinações próprias do IDE funcionam normalmente. Troque para outro app e os atalhos do Rectangle voltam automaticamente.

O modo tela cheia muda o que uma janela sequer é. Se seu editor ou terminal roda em tela cheia nativa do macOS (seu próprio Espaço) em vez de como uma janela normal maximizada, as ações do Rectangle de mover para outro monitor e redimensionar não se aplicam da mesma forma que a um app em modo janela — apps em tela cheia não são janelas móveis comuns. Mantenha em modo janela os apps que você quer que o Rectangle gerencie.

Automatizando um layout em vez de remontá-lo na mão

Como o Rectangle expõe um esquema de URL, um layout diário fixo pode ser reduzido a um único script em vez de quatro toques de teclado separados toda manhã:

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

Cada bloco ativa um app, espera um pouco até ele vir para frente, e então dispara a ação correspondente do Rectangle. Salve isso como um script de shell ou conecte a uma macro do Keyboard Maestro disparada por um atalho, e “montar meu layout de código” vira um único toque de tecla em vez de quatro. Isso precisa ser montado manualmente e não se adapta automaticamente a qual monitor está conectado — esse tipo de automação disparada pela conexão de um monitor é um recurso embutido no Rectangle Pro, e não algo que scripts no nível gratuito reproduzam de forma limpa.

Referência rápida

Layout	Atalhos
Editor + terminal, um monitor	⌃⌥← / ⌃⌥→
Editor + terminal, divisão desigual	⌃⌥E (editor) / ⌃⌥G (terminal)
Editor + terminal + navegador, três colunas	⌃⌥D, circular com pressões repetidas
Editor no segundo monitor	⌃⌥⌘→ e depois ⌃⌥↩
Ignorar os atalhos próprios do IDE	Dar foco ao IDE → menu do Rectangle → Ignorar app

開発者のためのRectangle:実際に使えるIDE・ターミナル・ブラウザのレイアウト

開発作業の大部分は、同じ3つか4つのウィンドウの間を行き来することで成り立っている。エディタやIDE、ターミナル、ドキュメントや実行中のアプリを表示するブラウザ、そして時には無視しようとしているメッセージアプリだ。Rectangle appの標準ショートカットセットは、無料アプリに最初から入っているもの以外何も必要とせずに、そのローテーションにきれいに対応する。ここでは、知っておく価値のあるレイアウトと、開発者向けツールで具体的に発生する問題を扱う。

単一モニター:2つのウィンドウ

もっとも単純で、もっともよくあるケースだ。もっとも見る頻度の高いほうをエディタに、もう一方をターミナルやドキュメントに割り当てる。

• ⌃⌥← — エディタを左半分へ
• ⌃⌥→ — ターミナルやブラウザを右半分へ

エディタにとって50/50の分割が狭く感じる場合(13〜14インチの画面では、コードエディタがターミナルよりも横幅を必要とするため、よくある不満だ)、まったく別のレイアウトに切り替えるのではなく、⌃⌥=(拡大)を数回押して片側を大きくするといい。組み込みの「60/40の半分」というアクションは存在しないため、すでに半分に分割されたウィンドウに対して拡大・縮小を使うのが、それに近づける方法になる。

単一モニター:3つのウィンドウ

ここで、半分よりも3分の1が本領を発揮する。理にかなった分割の一例:

• ⌃⌥E(最初の3分の2)— エディタ。コードはターミナルよりも横幅の恩恵を受けやすいため
• ⌃⌥G(最後の3分の1)— ターミナル

これにより、エディタが画面の3分の2を、ターミナルが3分の1を占めることになり、どちらも仕切り線をドラッグすることなくキーボードだけで到達できる。代わりにほぼ均等な3列にしたい場合は、⌃⌥D(最初の3分の1)でウィンドウを巡回させる。同じウィンドウでもう一度押すと中央の3分の1に、さらに押すと最後の3分の1に切り替わるので、エディタ・ターミナル・ブラウザをそれぞれ3つの位置に個別に配置すればいい。

2台のモニター:開発者によくある構成

ノートパソコンに外部ディスプレイをつないでいる場合、典型的な分割はこうなる。

• エディタを外部ディスプレイで最大化(⌃⌥↩)する。もっとも大きく鮮明な画面には、1日中見つめるものをふさわしく配置する。
• エディタの隣にターミナルを表示したいなら、外部ディスプレイの半分か3分の1に置く。外部ディスプレイを1つのアプリ専用にしたいなら、⌃⌥⌘←でノートパソコンの画面に移動させる。
• ブラウザやドキュメントはノートパソコンの画面に置き、最大化するか、メッセージアプリと半分ずつに分ける。

どのアプリをどの画面に置くかを頻繁に入れ替える場合、たとえばノートパソコンの画面を投影しながら外部ディスプレイにメモを残しておくような場合、次のディスプレイと前のディスプレイを使えば、ドラッグし直すことなくアクティブなウィンドウを移動できる。この操作が指の記憶になれば、手作業でドラッグするより速い。

開発者向けツールに特有の、既知の摩擦ポイント

ターミナル系アプリと文字幅単位のサイズ変更。 iTerm2はデフォルトでは、任意のピクセル単位ではなく文字幅の整数倍単位でしかサイズを変更しない。そのため、Rectangle macが計算した半分や3分の1のサイズが、通常のGUIアプリで得られるものからわずかにずれることがある。文書化されている修正方法は次の通りだ。

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

実行後はiTerm2を再起動する。Rectangle app自身のメンテナーによれば、Apple純正のTerminal.appも同じ丸め誤差の挙動を示すが、現時点で同等の修正方法は文書化されていない。ピクセル単位で正確なターミナルサイズにこだわりたいなら、この設定を適用したiTerm2のほうが、Terminal.appよりも予測しやすい挙動になる。

独自のキーボードショートカットを持つIDE。 VS CodeやJetBrains系のIDE、その他似たようなツールは、パネル間の移動やリファクタリング用のショートカットなど、自分たちのコマンドにControl + Optionの組み合わせをよく使っており、Rectangle appの標準設定と衝突することがある。Rectangle appをグローバルに再割り当てするのではなく、そのIDEに対してだけアプリを無視を使うといい。IDEをアクティブにし、Rectangleのメニューを開いて「アプリを無視」を選ぶ。これにより、そのIDEが最前面にある間だけRectangleのショートカットが登録解除され、IDE自身のキー割り当てが通常通り機能する。別のアプリに切り替えれば、Rectangleのショートカットは自動的に元に戻る。

フルスクリーンモードは、ウィンドウの本質を変えてしまう。 エディタやターミナルが、通常の最大化されたウィンドウとしてではなく、macOSネイティブのフルスクリーン(専用のスペース)として動作している場合、Rectangleのディスプレイ移動やサイズ変更の操作は、通常のウィンドウモードのアプリに対するようには適用されない。フルスクリーンアプリは、普通の移動可能なウィンドウではないからだ。Rectangleに管理させたいアプリは、ウィンドウモードのままにしておこう。

レイアウトを手作業ではなくスクリプトで組む

RectangleはURLスキームを公開しているため、毎朝4回別々にキーを押す代わりに、決まった日々のレイアウトを1つのスクリプトにまとめてしまえる。

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

それぞれのブロックはアプリをアクティブにし、そのアプリが最前面に来るまで少し待ってから、対応するRectangleのアクションを実行する。これをシェルスクリプトとして保存するか、ホットキーで発動するKeyboard Maestroのマクロに組み込めば、「自分のコーディング用レイアウトを整える」という作業が、4回ではなく1回のキー入力で済むようになる。ただし、これは手作業で組み立てる必要があり、どのディスプレイが接続されているかに応じて自動的に切り替わるわけではない。ディスプレイの接続をトリガーにした自動化は、無料版のスクリプトできれいに再現できるものではなく、Rectangle Proに組み込まれた専用機能だ。

クイックリファレンス

レイアウト	ショートカット
エディタ+ターミナル、単一モニター	⌃⌥← / ⌃⌥→
エディタ+ターミナル、非対称の分割	⌃⌥E(エディタ)/ ⌃⌥G(ターミナル)
エディタ+ターミナル+ブラウザ、3列	⌃⌥D、繰り返し押して巡回
エディタを2台目のディスプレイへ	⌃⌥⌘→ の後に ⌃⌥↩
IDE自身のショートカットを無視する	IDEをアクティブに → Rectangleメニュー → アプリを無視

Rectangle per sviluppatori: layout per IDE, terminale e browser che funzionano

Gran parte del lavoro di sviluppo ruota intorno alle stesse tre o quattro finestre: un editor o un IDE, un terminale, un browser per la documentazione o un’app in esecuzione, e a volte un’app di messaggistica che si cerca di ignorare. Il set di scorciatoie predefinito di Rectangle app si adatta perfettamente a questa rotazione, senza bisogno di nulla di più di quello che offre già l’app gratuita. Qui trovi i layout che vale la pena conoscere e i problemi specifici che emergono con gli strumenti di sviluppo.

Un solo monitor: due finestre

Il caso più semplice e più comune. L’editor occupa la metà che guardi di più; il terminale o la documentazione l’altra:

• ⌃⌥← — l’editor nella metà sinistra
• ⌃⌥→ — il terminale o il browser nella metà destra

Se la divisione 50/50 risulta stretta per l’editor (una lamentela comune su uno schermo da 13-14 pollici, dove un editor di codice vuole più spazio orizzontale di un terminale), ingrandisci un lato un paio di volte con ⌃⌥= (Ingrandisci) invece di passare a un layout completamente diverso. Non esiste un’azione integrata per “metà 60/40”; usare Ingrandisci/Rimpicciolisci su una finestra già divisa a metà è il modo per avvicinarsi a quel risultato.

Un solo monitor: tre finestre

È qui che i terzi si guadagnano il loro posto rispetto alle metà. Una divisione ragionevole:

• ⌃⌥E (primi due terzi) — l’editor, dato che il codice beneficia della larghezza più di un terminale
• ⌃⌥G (ultimo terzo) — il terminale

Questo dà all’editor due terzi dello schermo e al terminale un terzo, entrambi raggiungibili da tastiera senza trascinare alcun divisore. Se preferisci tre colonne all’incirca uguali, fai scorrere una finestra con ⌃⌥D (primo terzo); premerlo di nuovo sulla stessa finestra passa al terzo centrale, poi all’ultimo terzo, e posiziona editor, terminale e browser ciascuno in una delle tre posizioni.

Due monitor: la configurazione tipica dello sviluppatore

Con un display esterno collegato a un portatile, una divisione tipica:

• Editor massimizzato (⌃⌥↩) sul display esterno: lo schermo più grande e nitido merita ciò che guardi tutto il giorno.
• Terminale in metà o un terzo del display esterno se vuoi vederlo accanto all’editor, oppure spostato sullo schermo del portatile con ⌃⌥⌘← se preferisci riservare il display esterno a una sola app.
• Browser o documentazione sullo schermo del portatile, massimizzato o diviso a metà con un’app di messaggistica.

Se cambi spesso quale app si trova su quale schermo, ad esempio quando presenti lo schermo del portatile mantenendo appunti sul display esterno, Display successivo e Display precedente spostano la finestra attiva senza doverla trascinare di nuovo, il che è più veloce di un trascinamento manuale una volta acquisita la memoria muscolare.

Punti di attrito noti specifici per gli strumenti di sviluppo

App di terminale e ridimensionamento per larghezza di carattere. Per impostazione predefinita, iTerm2 si ridimensiona solo a incrementi di intere larghezze di carattere invece che in pixel arbitrari, il che significa che la metà o il terzo calcolato da Rectangle mac può risultare leggermente diverso da quello che otterresti con un’app grafica normale. La correzione documentata:

defaults write com.googlecode.iterm2 DisableWindowSizeSnap -integer 1

Riavvia iTerm2 dopo averlo eseguito. Il Terminale di Apple stesso presenta lo stesso comportamento di arrotondamento senza che sia attualmente documentata una correzione equivalente, secondo lo stesso maintainer di Rectangle app; se per te conta avere dimensioni del terminale precise al pixel, iTerm2 con questa impostazione applicata si comporta in modo più prevedibile rispetto a Terminale.

IDE con proprie scorciatoie da tastiera. VS Code, gli IDE JetBrains e strumenti simili usano spesso combinazioni Control + Opzione per i propri comandi (navigare tra i pannelli, scorciatoie di refactoring), il che può entrare in collisione con le impostazioni predefinite di Rectangle app. Invece di riassegnare Rectangle a livello globale, usa Ignora app specificamente sull’IDE: portalo in primo piano, apri il menu di Rectangle, scegli Ignora app. Le scorciatoie di Rectangle si disattivano allora solo finché quell’IDE è in primo piano, e le combinazioni proprie dell’IDE funzionano normalmente. Passa a un’altra app e le scorciatoie di Rectangle tornano automaticamente.

La modalità schermo intero cambia cosa sia davvero una finestra. Se il tuo editor o terminale funziona in modalità schermo intero nativa di macOS (il proprio Spazio) invece che come una normale finestra massimizzata, le azioni di Rectangle per spostarsi tra display e ridimensionare non si applicano come farebbero con un’app in modalità finestra; le app a schermo intero non sono normali finestre spostabili. Mantieni in modalità finestra le app che vuoi che Rectangle gestisca.

Scriptare un layout invece di ricostruirlo a mano

Dato che Rectangle espone uno schema URL, un layout quotidiano fisso può essere ridotto a un unico script invece di quattro pressioni da tastiera separate ogni mattina:

open -a "Visual Studio Code"
sleep 0.5
open -g "rectangle://execute-action?name=first-two-thirds"

open -a "iTerm"
sleep 0.5
open -g "rectangle://execute-action?name=last-third"

Ogni blocco attiva un’app, attende brevemente che passi in primo piano, poi attiva l’azione Rectangle corrispondente. Salva questo come script di shell oppure collegalo a una macro di Keyboard Maestro attivata da una scorciatoia, e “imposta il mio layout di lavoro” diventa una singola pressione di tasto invece di quattro. Questo va costruito manualmente e non si adatta automaticamente a quale display sia collegato; questo tipo di automazione attivata al collegamento del display è una funzione integrata in Rectangle Pro, non qualcosa che lo scripting del livello gratuito riproduce in modo pulito.

Riferimento rapido

Layout	Scorciatoie
Editor + terminale, un solo monitor	⌃⌥← / ⌃⌥→
Editor + terminale, divisione asimmetrica	⌃⌥E (editor) / ⌃⌥G (terminale)
Editor + terminale + browser, tre colonne	⌃⌥D, scorri con pressioni ripetute
Editor sul secondo display	⌃⌥⌘→ poi ⌃⌥↩
Ignora le scorciatoie proprie dell’IDE	Porta in primo piano l’IDE → menu Rectangle → Ignora app