Gokurakujoudo

https://github.com/yqrashawn/gokurakujoudo
Admin
GokuRakuJoudo is a tool that simplifies the management of Karabiner configuration files by allowing...
Tokens:10,445
Snippets:46
Trust Score:9.5
License:GPL-3.0
Update:1 year ago
Show doc for...
Tokens:
Raw
### Simlayer Example: 'w' as Launch Mode Key

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Demonstrates using a regular key, 'w', as a simlayer key to create a 'launch-mode'. When 'w' is held, 'k' opens Emacs and 'l' opens Chrome. This example uses the `simlayers` and `templates` sections.

```clojure
{:templates {:open "open \"%s\""}
 :layers    {}
 :simlayers {;; make w key a simlayer key
             ;; layers works too, but only recommended for none typing keys
             ;; like . , tab
             ;; or keys like z, which used less often
             :launch-mode {:key :w}}
 :main      [{:des   "launch mode"
              :rules [:launch-mode
                      [:k [:open "/Applications/Emacs.app"]]
                      [:l [:open "/Applications/Google Chrome.app"]]]}]}
```

--------------------------------

### Simlayer Example: Explicit Condition Syntax

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

An alternative syntax for the previous simlayer example, explicitly applying the `:launch-mode` condition to each rule. This illustrates how conditions (layer, simlayer, application, input-source, device) can be applied to rules.

```clojure
{:templates {:open "open \"%s\""}
 :layers    {}
 :simlayers {:launch-mode {:key :w}}
 :main      [{:des   "launch mode"
              :rules [[:k [:open "/Applications/Emacs.app"] :launch-mode]
                      [:l [:open "/Applications/Google Chrome.app"] :launch-mode]]}]}
```

--------------------------------

### Modifier Key Handling Examples

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Illustrates how to remap keys involving modifier keys like Shift, Control, Option, and Command. Includes examples for mapping `shift + 1` to `1`, `1` to `!`, and `control + shift + 1` to `12`. Explains common modifier key abbreviations used in GokuRakuJoudo.

```clojure
{:main [{:des   "demo modifier keys"
         :rules [
                 ;; shift 1 to 1
                 ;; !S here means shift
                 [:!S1 :1]
                 ;; 1 to !
                 [:1 :!S1]
                 ;; control shift 1 to 12
                 ;; !TS means control shift
                 [:!TS1 [:1 :2]]]}]}

;; C T O S stands for left_command left_control left_option left_shift
;; Q W E R stands for right_command right_control right_option right_shift

;;;; hyper
;; !! stands for left_command + left_control + left_option + left_shift
;; :!!1 left_command + left_control + left_option + left_shift + 1
```

--------------------------------

### Layer Example: Alfred and Launch Modes Combined

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Combines simlayers and traditional layers. Defines a 'launch-mode' using 'w' and an 'alfred-layer' using 'z'. It shows how to define rules for both modes, including opening applications and triggering Alfred workflows using `osascript`.

```clojure
{:templates {:open   "open \"%s\""
             :alfred "osascript -e 'tell application \"Alfred 3\" to run trigger \"%s\" in workflow \"%s\" with argument \"%s\"'"}
 :layers    {:alfred-layer {:key :z}}
 :simlayers {:launch-mode {:key :w}}
 :main      [{:des   "launch mode"
              :rules [:launch-mode
                      [:k [:open "/Applications/Emacs.app"]]
                      [:l [:open "/Applications/Google Chrome.app"]]]}

             {:des   "alfred mode"
              :rules [:alfred-mode
                      [:h [:alf "search repos" "me.lachlan.githubjump"]]
                      [:x [:alf "killProcess" "com.ngreenstein.alfred-process-killer"]]]}]}
```

--------------------------------

### Minimal GokuRakuJoudo Configuration

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Demonstrates the most basic configuration for GokuRakuJoudo. This configuration does not perform any actions and requires a 'Default' profile in karabiner.json.

```clojure
{}
```

--------------------------------

### Layer Example: Partial Character Key as Modifier

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

A partial configuration demonstrating how a character key can act as a modifier key within a `main` rule block, specifically for the 'launch-mode' simlayer. This snippet is incomplete but shows the structure.

```clojure
{:templates {:open   "open \"%s\""
             :alfred "osascript -e 'tell application \"Alfred 3\" to run trigger \"%s\" in workflow \"%s\" with argument \"%s\"'"}
 :layers    {:alfred-layer {:key :z}}
 :simlayers {:launch-mode {:key :w}}
 :main      [{:des   "character key as modifier key rules"
              :rules [:launch-mode
                      [:k [:open "/Applications/Emacs.app"]]]}
```

--------------------------------

### Conceptual Simlayer Key Event Processing with Threshold

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This conceptual example demonstrates Karabiner's 'simlayer' functionality, which is based on simultaneous key presses. It explains how a 'w' key press, if followed by another key within a threshold, activates a layer, allowing subsequent keys to trigger layer definitions. It also shows how the 'w' key starts repeating if no second key is pressed within the threshold, addressing the old layer's repetition issue.

```Textual Description
press w key down --> if in threshold milliseconds
                            --> press 1 key ("w layer" set to 1)
                            --> in w layer and trigger the 1 definition
                                --> press 2 key even after the threshold ("w layer" is still 1)
                                --> in w layer and trigger the 2 definition
                                    --- we hold the w key for 1 year ---> ("w layer" is still 1)
                                    release w to set "w layer" to 0
                         --> if after threshold milliseconds
                         --> w key begin to repeat, we get "wwwwwwwwwwwww"
```

--------------------------------

### Karabiner-Elements: Multitouch Condition Examples

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

This configuration demonstrates how to use Karabiner-Elements' multitouch feature to apply rules based on the number of fingers on a trackpad. It shows remapping `ctrl+y` to `command+v` conditionally, based on the total finger count or fingers on a specific area of the trackpad.

```Clojure
  {:des "ctrl+y to command+v (trackpad example)"
   :rules
   [;; ctrl+y to command+v
    [:!Ty :!Cv]
    ;; ctrl+y to command+v when one finger on trackpad
    [:!Ty :!Cv :multitouch_extension_finger_count_total]
    ;; ctrl+y to command+v when one finger on trackpad
    [:!Ty :!Cv ["multitouch_extension_finger_count_total" 1]]
    ;; ctrl+y to command+v when two finger on trackpad
    [:!Ty :!Cv ["multitouch_extension_finger_count_total" 2]]
    ;; ctrl+y to command+v when three finger on the upper half of trackpad
    [:!Ty :!Cv ["multitouch_extension_finger_count_upper_half_area" 3]]]}
```

--------------------------------

### Karabiner-Elements: Device and Application Specific Rules

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

This configuration illustrates how to define and use device-specific (e.g., HHKB keyboard) and application-specific (e.g., Browsers) conditions in Karabiner-Elements. It explains how to find `vendor_id`, `product_id`, and `bundle_identifiers` for defining these conditions.

```Clojure
{:layers        {:z-mode {:key :z}}
 :devices       {;; define devices
                 ;; vendor_id and product_id can be found in Karabiner EventViewer gui
                 :hhkb [{:vendor_id 2131 :product_id 256}]}
 :applications  {;; define applications
                 :Browsers [;; these strings are regex to match applications bundle_identifiers
                            ;; you can find bundle_identifiers in the Info.plist file of an applications
                            ;; eg. in /Applications/Mail.app/Contents/Info.plist
                            ;; search for "CFBundleIdentifier"
                            ;; you can also find bundle_identifiers using command line:
                            ;; osascript -e 'id of app "Google Chrome"'
```

--------------------------------

### Karabiner-Elements Main Rules with Conditions

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Demonstrates how to define application patterns, input sources, and main rules in Karabiner-Elements using GokuRakuJoudo. It shows various ways to apply conditions to key remapping rules, including multiple conditions and inline conditions, based on active applications, input sources, and custom modes.

```Clojure
                            "^org\\.mozilla\\.firefox$"
                            "^org\\.mozilla\\.firefoxdeveloperedition$"
                            "^com\\.google\\.Chrome$"
                            "^org\\.chromium\\.Chromium$"
                            "^com\\.google\\.Chrome\\.canary$"
                            "^com\\.apple\\.Safari$"]}
 :input-sources {;; define input-source, these data can be founhd in Karabiner EventViewer gui
                 :us {:input_mode_id   ""
                      :input_source_id "com.apple.keylayout.US"
                      :language        "en"}}

 ;; can config like this
 :main [{:des   "contions demo"
         :rules [;; multiple conditions
                          ;;;; when
                 ;; the input-method is :us
                 ;; the activated application is one of app in :Browsers
                 ;; the key is triggered by :hhkb
                 ;; may l key to command + optional + l
                 [:condi :us :hhkb :Browsers :z-mode]
                 [:l :!COi]]}]
 ;; or
 :main [{:des   "contions demo"
         :rules [[:l :!COi [:us :hhkb :Browsers :z-mode]]]}]

 ;; or
 :main [{:des   "contions demo"
         :rules [[:condi :us :hhkb]
                 [:l :!COi [:Browsers :z-mode]]]}]
```

--------------------------------

### Install GokuRakuJoudo using Homebrew

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/README.md

This command installs the GokuRakuJoudo tool on macOS systems using the Homebrew package manager. It first taps the custom repository "yqrashawn/goku" and then installs the "goku" formula, making the "goku" and "gokuw" commands available.

```Shell
brew install yqrashawn/goku/goku
```

--------------------------------

### Karabiner-Elements: Define Launch Mode Simlayer with Alfred Integration

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

This configuration sets up a 'launch-mode' simlayer, activated by `left_control+w`. It includes templates for opening applications and triggering Alfred workflows. The main rules define actions like opening Emacs and Chrome, and using Alfred for 'search repos' and 'killProcess' when in 'alfred-mode'.

```Clojure
{:templates {:open   "open \"%s\"",
             :alfred "osascript -e 'tell application \"Alfred 3\" to run trigger \"%s\" in workflow \"%s\" with argument \"%s\"'"}
 :layers    {:alfred-layer {:key :z}}
 :simlayers {:launch-mode {:key :w
                           ;; can omit the vector if only one modifier is used
                           ;; :modi {:mandatory :left_control}

                           ;; more examples
                           ;; :modi {:optional :any}
                           ;; :modi {:optional [:left_shift :left_command]
                           ;;        :mandatory :left_control}
                           :modi {:mandatory [:left_control]}}}
 :main      [{:des   "character key as modifier key rules"
              :rules [:launch-mode
                      ;; lctrl down and w+k run shell script "open /Applications/Emacs.app"
                      [:k [:open "/Applications/Emacs.app"]]
                      [:l [:open "/Applications/Google Chrome.app"]]
                      :alfred-mode ;; all conditions works this way
                      [:h [:alf "search repos" "me.lachlan.githubjump"]]
                      [:x [:alf "killProcess" "com.ngreenstein.alfred-process-killer"]]]}]}
```

--------------------------------

### Print Function Shortcuts for Multiple Languages

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

A Karabiner-Elements configuration defining custom keybindings to quickly insert print statements for Go (fmt.Println()), Python (print()), Elixir (IO.puts()), and Rust (println!()). Each rule is associated with a specific programming language mode.

```clojure
                  [:a [:f :m :t :period :!Sp :r :i :n :t :l :n :!S9 :!S0 :left_arrow]] ; -> fmt.Println()
                  [:v [:g :o :l :a :n :g :spacebar]]]} ; -> golang
          {:des "pydot"
           :rules[:py-mode
                  [:a [:p :r :i :n :t :!S9 :!S0 :left_arrow]] ; -> print()
                  [:v [:p :y :t :h :o :n :spacebar]]]} ; -> python
          {:des "elixdot"
           :rules[:elixir-mode
                  [:a [:!Si :!So :period :p :u :t :s :!S9 :!S0 :left_arrow]] ; -> IO.puts()
                  [:v [:e :l :i :x :i :r :spacebar]]]} ; -> elixir
          {:des "rustdot"
           :rules[:rust-mode
                  [:a [:p :r :i :n :t :l :n :!S1 :!S9 :!S0 :left_arrow]] ; -> println!()
                  [:v [:r :u :s :t :spacebar]]]}]}
```

--------------------------------

### Swap Semicolon and Colon Keys

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Configures key remapping to swap the ';' and ':' keys. It also defines behavior for shifted, command, option, and control combinations of the semicolon key.

```clojure
{:main [{:des "swap ; :"
         :rules [[:semicolon :!Ssemicolon]
                 [:!Ssemicolon :semicolon]]}]}
```

--------------------------------

### Simultaneous Key Press: J and L to F16

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Defines a rule to trigger `f16` when the `j` and `l` keys are pressed simultaneously.

```clojure
{:main [{:des   "press j and l simultaneously to f16"
         :rules [[[:j :l] :f16]]}]}
```

--------------------------------

### Double Command-Q to Quit Application

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Implements a robust double-tap Command-Q keybinding for quitting applications. It uses Karabiner-Elements variables and notifications to manage the two-stage press, displaying a 'Press Again to QUIT' message and resetting if the second press doesn't occur within a delay.

```clojure
{:des   "Quit application by pressing command-q twice"
 :rules [[
          ;; <from> second cmd-q (when variable "command-q" is 1)
          :!C#Pq
          ;; <to>, 3 to action
          ;; 1. call cmd-q
          ;; 2. set variable "command-q" to 0
          ;; 3. cleanup the :cmdq notification (omit the thrid item to cleanup notification)
          [:!Cq ["command-q" 0] [:noti :cmdq]]
          ;; <condition> when variable "command-q" is 1
          ["command-q" 1]]


         [
          ;; <from> first cmd-q (when variable "command-q" is 0)
          :!C#Pq

          ;; <to>, 2 to action
          ;; 1. show notification with :id :cmdq, :text "Press Again to QUIT"
          ;; 2. set variable "command-q" to 1 (for the second press)
          [[:noti :cmdq "Press Again to QUIT"] ["command-q" 1]]

          ;; <condition> nil means no required condition
          nil

          ;; <additional-option>
          {
           ;; to_delayed_action documentation
           ;; https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-delayed-action/
           :delayed {
                     ;; run 2 actions when no other key presses after basic.to_delayed_action_delay_milliseconds
                     ;; 1. set variable "command-q" to 0
                     ;; 2. cleanup notification :id :cmdq
                     :invoked  [["command-q" 0] [:noti :cmdq]]

                     ;; run 2 actions when another key presses within basic.to_delayed_action_delay_milliseconds
                     ;; 1. set variable "command-q" to 0
                     ;; 2. cleanup notification :id :cmdq
                     :canceled [["command-q" 0] [:noti :cmdq]]}}]]}
```

--------------------------------

### Karabiner-Elements Default Profile Configuration

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Illustrates the configuration of a default profile in Karabiner-Elements, specifying parameters like simultaneous key press threshold (:sim), delayed action delay (:delay), to_if_alone timeout (:alone), and to_if_held_down threshold (:held). This profile acts as the base for rules without explicit profile assignments.

```Clojure
{:profiles {:Default {;; "default true means" rules default goes into this rule if no profiles specified
                      :default true
                      ;; simultaneous key press threshold
                      ;; simlayer is implemented with to_if_alone and simultaneous key press feature
                      :sim     250
                      ;; to_delayed_action_delay_milliseconds
                      ;; checkout karabiner's documentation
                      ;; https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-delayed-action/
                      ;; basically it means time after which the key press is count delayed
                      :delay   500
                      ;; https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/to-if-alone/
                      ;; to_if_alone_timeout_milliseconds
                      ;; affects to_if_alone behavior
                      ;; simlayer is implemented with to_if_alone and simultaneous key press feature
                      :alone   1000
                      ;; to_if_held_down_threshold_milliseconds
                      ;; check the doc, I don't know what does this mean.
                      ;; maybe press this many milliseconds counts a "held" ?
                      :held    500}}}
```

--------------------------------

### Karabiner-Elements: Double-Tap Right Shift for Mode Toggle

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

This configuration implements a 'double-right-shift-mode' that is activated by double-tapping the right shift key. A single tap of right shift exits this mode. It uses a delayed condition to track the 'shift-pressed-once' state and provides an example action within the mode.

```Clojure
  {:des   "Press right_shift twice to enter double shift mode, press right_shift once to leave it"
                         :rules [[:right_shift ["double-right-shift-mode" 1] ["shift-pressed-once" 1]]
                                 [:right_shift [:right_shift ["shift-pressed-once" 1]] ["double-right-shift-mode" 0] {:delayed {:invoked ["shift-pressed-once" 0] :canceled ["shift-pressed-once" 0]}}]
                                 :double-right-shift-mode
                                 [:right_shift ["double-right-shift-mode" 0]]
                                 [:a "say 'know we are in double shift mode'"]]}
```

--------------------------------

### Karabiner-Elements Mode-Specific Keybindings with Simlayers

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Shows how to configure mode-specific keybindings using profiles and simlayers in Karabiner-Elements. It defines a default profile with timing parameters and various simlayers (e.g., :js-mode, :go-mode) that activate based on Karabiner CLI variables, allowing different key behaviors in different programming language contexts.

```Clojure
  {:profiles
   {:Default {:default true
              :sim     50
              :delay   80
              :alone   120
              :held    70}}
   :simlayers {:js-mode {:key :period :condi ["in-js" 1]} ;;  karabiner_cli --set-variables {"in-js": 1}
               :go-mode {:key :period :condi ["in-go" 1]} ;;  karabiner_cli --set-variables {"in-go": 1}
               :py-mode {:key :period :condi ["in-python" 1]} ;;  karabiner_cli --set-variables {"in-python": 1}
               :elixir-mode {:key :period :condi ["in-elixir" 1]} ;;  karabiner_cli --set-variables {"in-elixir": 1}
               :rust-mode {:key :period :condi ["in-rust" 1]}} ;;  karabiner_cli --set-variables {"in-rust": 1}
   :main [{:des "jsdot"
           :rules [:js-mode
                   [:a [:c :o :n :s :o :l :e :period :l :o :g :!S9 :!S0 :left_arrow]] ; -> console.log()
                   [:v [:j :a :v :a :s :c :r :i :p :t :spacebar]]]}
          {:des "godot"
           :rules[:go-mode
```

--------------------------------

### Remap Right Command to F16

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Maps the `right_command` key to `f16`. The `##` prefix ensures that other modifier key combinations (like `left_command + right_command`) are also remapped accordingly. A note explains the behavior of the `##` prefix versus specific modifier prefixes like `#C`.

```clojure
{:main [{:des   "right_command to f16"
         :rules [[:##right_command :f16]]}]}
```

--------------------------------

### Caps Lock as Escape (Alone) or Control (Modifier)

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Configures the `caps_lock` key to act as `escape` when pressed and released alone, and as `left_control` when used as a modifier key in combination with other keys.

```clojure
{:main [{:des   "caps_lock to esc when pressed alone, to ctrl as modifier"
         :rules [[:##caps_lock :left_control nil {:alone :escape}]]}]}
```

--------------------------------

### Map Single Key to Modifier Key in Gokurakujoudo

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

Demonstrates how to remap a single key (e.g., 'a') to a modifier key (e.g., 'control 1') using a simplified modifier syntax. Explains the meaning of prefixes like `!C` for mandatory command and `!T` for mandatory control, along with other modifier definitions and examples.

```Clojure
{:main [{:des "command a to control 1" :rules [[:!Ca :!T1]]}]}
```

--------------------------------

### Disable All Pointing Device Buttons

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

A Karabiner-Elements rule that disables all input from pointing device buttons by mapping any pointing button event to vk_none, effectively preventing mouse clicks or other button actions.

```clojure
  {:des "disable all pointing buttons"
   :rules [[{:any :pointing_button} :vk_none]]}
```

--------------------------------

### GokuRakuJoudo Development and Compilation Commands

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/README.md

These commands are essential for developing and building GokuRakuJoudo. "lein repl" starts a Clojure interactive development environment. "make compile" compiles the Clojure source code into a Java Archive (JAR) file. "make bin" then uses GraalVM's "native-image" tool to compile the JAR into a native executable, assuming "native-image" is in the system's PATH.

```Shell
lein repl
make compile
make bin
```

--------------------------------

### Predefine From Event Definitions in Goku for Karabiner-Elements

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This section illustrates how to predefine 'from' event definitions in Goku for Karabiner-Elements. It provides examples for disabling various input types like consumer keys, key codes, and pointing buttons, as well as remapping control-left-click to command-left-click. It also shows how to set simultaneous options for key combinations.

```Clojure
        ;; from any key_code, consumer_key_code, any pointing_button or one pointing_button
        {:froms {:from-any-consumer-key {:any "consumer_key_code"}}
         :main [{:des "disable all consumer key"
                 :rules [[:from-any-consumer-key :vk_none]]}]}

        {:froms {:from-any-keycode-key {:any "key_code"}}
         :main [{:des "disable keycode key"
                 :rules [[:from-any-keycode-key :vk_none]]}]}

        {:froms {:from-any-pointing-button {:any "pointing_button"}}
         :main [{:des "disable all pointing button"
                 :rules [[:from-any-keycode-key :vk_none]
                         [{:any "pointing_button"} :vk_none]]}]}

        {:froms {:from-control-left-click {:pkey :button1 :modi :left_control}}
         :main [{:des "control left-click to command left-click"
                 :rules [[:from-control-left-click {:pkey :button1 :modi :left_command}]]}]}


        ;; configs above disable all kinds of keys.
        ;; rule [<from> <to> <conditions>]
        ;; we can put predefined from keyword into <from> section
        ;; or we can just put the from definition map into <from> section, since we
        ;; usually only use each froms one time.

        ;; WARNING
        ;; This is just a demonstration of what can be done with :any. DON'T TRY any of
        ;; these three rules, they will disable all your keyboard key and mouse button.

        ;; set simultaneous_options
        {:sim [:f :j]
         :simo {:interrupt true
                :dorder :strict
                :uorder :strict_inverse
                :afterup {:set ["fj layer" 1]}}}
```

--------------------------------

### GokuRakuJoudo Command-Line Usage

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/README.md

Goku provides several command-line utilities for managing Karabiner configurations. The "goku" command performs a single update of the "karabiner.json" file. The "gokuw" command continuously watches the "karabiner.edn" file for changes and updates "karabiner.json" automatically. For background operation, "brew services start goku" runs "gokuw" as a system service. Use "goku -h" to display help information.

```Shell
goku
gokuw
brew services start goku
goku -h
```

--------------------------------

### Karabiner-Elements: Custom Variable for Alfred Control

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

This configuration demonstrates using a custom variable 'in-alfred' to manage Alfred's state. It sets F16 as the trigger key for Alfred, and then defines rules for navigating Alfred results (down/up arrow), selecting an item (enter), and exiting (escape), all while updating the 'in-alfred' variable.

```Clojure
{:main [{:des   "alfred"
         :rules [;; set f16 as the trigger key of alfred
                 ;; press h + l will trigger alfred and set "in-alfred" to 1
                 [[:h :j] [:f16 ["in-alfred" 1]]]

                 :in-alfred ;; when "in-alfred" is 1

                 ;; press enter will select one alfred result and set "in-alfred" to 0
                 [:##return_or_enter [:return_or_enter ["in-alfred" 0]]]

                 ;; press esc will exit alfred and set "in-alfred" to 0
                 [:##escape [:escape ["in-alfred" 0]]]

                 ;; press ctrl + j will invoke down_arrow
                 [:!Tj :down_arrow]

                 ;; press ctrl + k will invoke up_arrow
                 [:!Tk :up_arrow]

                 ;; press ctrl + l will invoke return_or_enter and set "in-alfred" to 0
                 [:!Tl [:return_or_enter ["in-alfred 0"]]]]}]}
```

--------------------------------

### Conceptual Old Layer Key Event Processing

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This conceptual example illustrates how the 'old layer' in Karabiner processes key events. It shows a sequence where pressing a 'w' key activates a layer, and subsequent key taps (like '1' or '2') trigger definitions within that layer. The layer deactivates upon 'w' key release.

```Textual Description
press w key down --> in w layer ("w layer" set to 1)
        tap 1 key      --> trigger key 1's definition under w layer ("w layer" is 0)
        tap 2 key      --> trigger key 2's definition under w layer ("w layer" is 0)
        release w key up --> out w layer ("w layer" is 0)
```

--------------------------------

### Karabiner.json Null Rule Example from EDN Comment

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/README.md

This JSON snippet demonstrates how a commented-out rule in the "karabiner.edn" configuration file (using "#_") is represented in the generated "karabiner.json". It results in a rule with a "null" description and an empty "manipulators" array, which does not cause errors in Karabiner.

```JSON
{
      "description" : null,
      "manipulators" : [ ]
    }
```

--------------------------------

### Two-Stroke Keybindings with Right Shift Mode

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/examples.org

Configures two-stroke keybindings, similar to Emacs C-x mode, using the Right Shift key as a temporary mode activator. Pressing Right Shift alone enters 'right-shift-mode', allowing subsequent keys (e.g., 'a') to trigger specific actions (e.g., opening a URL), with the mode automatically resetting after a key press or timeout.

```clojure
{:des "tap right shift then keys"
 :rules [
         ; If right-shift-mode is on, run this command when a is pressed. Anything that depends
         ; on the mode being set must come _before_ the delayed declaration.
         [:a "open https://github.com/yqrashawn/GokuRakuJoudo" [:right-shift-mode]]
         ; Send right_shift unconditionally (so it still works as a modifier key)
         [:right_shift :right_shift nil
          ; and if pressed alone, trigger right-shift-mode
          {:alone [:right_shift ["right-shift-mode" 1]]
           ; when another key is invoked, or after a timeout, set the mode back to zero
           :delayed {:invoked ["right-shift-mode" 0] :canceled ["right-shift-mode" 0]}}]]}
```

--------------------------------

### Use Predefined String Templates for Commands in Gokurakujoudo

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

Explains how to use predefined string templates to simplify long or repetitive shell commands and AppleScripts. Demonstrates defining a `:launch` template and then using it within rules, where `%s` placeholders are replaced by arguments. Mentions that it uses Clojure's (Java's) string template implementation.

```Clojure
{:templates {:launch "osascript -e 'tell application \"Alfred 3\" to run trigger \"launch%s\" in workflow \"yqrashawn.workflow.launcher\" with argument \"%s\"'"}
     :main [{:des "launcher mode"
             :rules [[:j [:launch "Alacritty"] :launch-mode]
                     [:k [:launch "Emacs"] :launch-mode]
                     [:l [:launch "Chrome"] :launch-mode]
                     [:m [:launch "Mail"] :launch-mode]
                     [:v [:launch "WeChat"] :launch-mode]
                     [:q [:launch "KE"] :launch-mode]
                     [:f [:launch "Finder"] :launch-mode]
                     [:9 [:launch "PDFExpert"] :launch-mode]
                     [:comma [:launch "Safari"] :launch-mode]
                     [:period [:launch "Paw"] :launch-mode]
                     [:equal_sign [:launch "Textual"] :launch-mode]
                     [:8 [:launch "KEEvents"] :launch-mode]
                     [:b [:launch "BearyChat"] :launch-mode]
                     [:t [:launch "TG"] :launch-mode]]}]}
```

--------------------------------

### Define Basic Key Remappings in Goku (Clojure)

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This snippet demonstrates how to define simple key remappings using Goku's configuration. It shows how to map single keys to single outputs, or a single key to a sequence of outputs. It also illustrates how to group multiple remappings into a single manipulator or separate them into distinct manipulators.

```Clojure
    ;; main contains multiple manipulators
    ;; each manipulator has a description and multiple rules

    ;; main                -> {:main [{:des "..." :rules [rule1 rule2 ...]}]}
    ;; manipulator         -> {:des "..." :rules [rule1 rule2 ...]}
    ;; manipulator's rules -> [rule1 rule2 ...]
    {:main [{:des "a to 1, b to 2, c to insert 1 2 3"
             :rules [[:a :1] [:b :2] [:c [:1 :2 :3]]]}]}

    ;; or we can separate them into three manipulators
    {:main [{:des "a to 1" :rules [[:a :1]]}
            {:des "b to 2" :rules [[:b :2]]}
            {:des "c to insert 123" :rules [[:c [:1 :2 :3]]]}]}

    ;; in rules [:a :1] -- [<from> <to>]
    ;; it means from key a to key 1
    ;; these keycode is just original karabiner keycode prefix with colon
```

--------------------------------

### Define Key Remappings with Multiple Conditions in Goku (Clojure)

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This snippet demonstrates how to apply key remappings based on multiple conditions, including device, application, and input source. It shows how to define identifiers for devices and input sources, and combine them with application conditions to create highly specific remapping rules.

```Clojure
    {:devices {:hhkb-bt [{:vendor_id 1278 :product_id 51966}]}
         ;; you can also find bundle_identifiers using command line:
         ;; osascript -e 'id of app \"Google Chrome\"'
         :applications {:chromes ["^com\\.google\\.Chrome$" "^com\\.google\\.Chrome\\.canary$"]}

         :input-sources {:us {:input_mode_id ""
                              :input_source_id "com.apple.keylayout.US"
                              :language "en"}}

         :main [{:des "a to 1 multiple conditions"
                 :rules [[:a :1 [:chromes :hhkb-bt :us]]]}]}

        ;; so this means press a to insert 1 in Google Chrome and Google Chrome Canary
        ;; while we are using the US input method, and the device that press a is
        ;; HHKB-BT keyboard.
```

--------------------------------

### Goku Configuration for Simlayer Period Mode

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This Clojure-like configuration snippet demonstrates how to define a 'simlayer' named 'period-mode' in Goku, associated with the 'period' key. It includes rules for mapping keys like 'd', 'f', 'a', and 's' to specific actions (e.g., inserting parentheses or slashes) when the 'period-mode' simlayer is active.

```Clojure
{:simlayers {:period-mode {:key :period}}
         :main [{:des "period mode"
                 :rules [[:d :!S9 :period-mode] ;; .d insert (
                         [:f :!S0 :period-mode] ;; .f insert )
                         [:a [:!Sgrave_accent_and_tilde :slash] :period-mode] ;; .a insert ~/
                         [:s [:period :!S8] :period-mode]]}]}
```

--------------------------------

### Execute Shell Commands from Key Bindings in Gokurakujoudo

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

Shows how to configure a key binding to execute a shell command. A string in the 'to' part of the rule invokes the command. Includes a note about avoiding multiple shell commands in a single rule due to Karabiner-Elements limitations.

```Clojure
{:main [{:des "hyper 1 to cleanup personal folder"
             :rules [[:!!1 "rm -r ~/personal && mkdir ~/personal"]]}]}
```

--------------------------------

### Apply Application-Specific Key Remappings in Goku (Clojure)

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This snippet demonstrates how to apply key remappings only when specific applications are active. It shows how to define application identifiers and use them as conditions in remapping rules. It also illustrates how to apply multiple conditions and use negative conditions to exclude applications.

```Clojure
    {;; define application identifiers
     :applications {:chrome ["^com\\.google\\.Chrome$"]}
     :main [{:des "a to 1 only in chrome" :rules [[:a :1 :chrome]]}]}

    ;; [:a :1 :chrome] -- [<from> <to> <conditions>]
    ;; this means from a to 1 under the condition of chrome
    ;; :chrome is a predefined application condition
    ;; it's same with karabiner

    ;; and we can use multiple conditions
    {:applications {:chrome ["^com\\.google\\.Chrome$"]
                            :safari ["^com\\.apple\\.Safari$"]}
     :main [{:des "a to 1 only in chrome and safari" :rules [[:a :1 [:chrome]]
                                                                [:a :1 [:safari]]]}]}

    ;; we can also prefix use the opposite condition
    {:applications {:chrome ["^com\\.google\\.Chrome$"]
                            :safari ["^com\\.apple\\.Safari$"]}
     :main [{:des "a to 1 only outside chrome and safari" :rules [[:a :1 [:!chrome :!safari]]]}]}
```

--------------------------------

### Define Karabiner Layers (New Predefined Method)

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/CHANGELOG.org

This snippet demonstrates the new approach for defining Karabiner layers using a top-level `:layers` key for predefinition. This allows layers to be defined once and then referenced by name within rules, simplifying configuration and improving readability.

```clojure
;; now we can do it with predefined layer
{:layers {:wlayer {:key :w}}
 :main [{:des "w layer"
         :rules [[:e "open -a Emacs.app" :wlayer]
                 [:s "open -a Safari.app" :wlayer]]}]}
```

--------------------------------

### Define Keyboard Layers with Variable Conditions in Goku

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This snippet demonstrates how to use variable conditions in Goku to create keyboard layers. It shows how to set a variable 'w-layer' to 1 when the 'w' key is tapped, and how to combine key presses with variable setting for more complex behaviors.

```Clojure
    {:main [{:des "tap w to set w-layer to 1"
             :rules [[:w ["w-layer" 1]]]}]}

    ;; this means tap w to set variable "w layer" to 1
    ;; rule [:w     ["w layer" 1]]
    ;;      |____| |____________|
    ;;       <from>     <to>

    ;; we can also set multiple <to>, and use the defined variable in <conditions>
    {:main [{:des "tap w to insert w then set w-layer to 1"
             :rules [[:w [:w ["w-layer" 1]]]
                     [:1 [:1 :w] :w-layer]]}]}

    ;; rule [:w    [:w ["w layer" 1]]]
    ;;      |____| |_______________|
    ;;      <from>       <to>
```

--------------------------------

### Goku Configuration for Old Layer Period Mode

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/tutorial.md

This Clojure-like configuration snippet illustrates how to set up an 'old layer' in Goku for a 'period mode'. It defines rules where pressing the 'period' key activates the layer by setting a 'period-mode' variable to 1, and deactivates it on key release. Subsequent rules map keys like 'd', 'f', 'a', and 's' to actions when the 'period-mode' is active.

```Clojure
{:main [{:des "period mode"
                 :rules [[:period ["period-mode" 1] nil {:afterup ["period-mode" 0]
                                                         :alone :period}]
                         [:d :!S9 ["period-mode" 1]]
                         [:f :!S0 ["period-mode" 1]]
                         [:a [:!Sgrave_accent_and_tilde :slash ] ["period-mode" 1]]
                         [:s [:period :!S8] ["period-mode" 1]]]}]}
```

--------------------------------

### Karabiner-Elements Application Definition for Complex Modifications

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/CHANGELOG.org

This Clojure snippet illustrates how to define application identifiers and file paths within Karabiner-Elements' complex modifications configuration. It demonstrates specifying applications using identifiers (bundle IDs) and file paths, supporting regular expressions and multiple entries for flexible application matching in rules.

```Clojure
{...
 :applications
 {:Chromes ["^org\.chromium\.Chromium$" "^com\.google\.Chrome\.canary$" :paths "^/Applications/Google Chrome\.app"]
  ;; same as
  :Chromes [:identifiers "^org\.chromium\.Chromium$" "^com\.google\.Chrome\.canary$" :paths "^/Applications/Google Chrome\.app"]

  ;; can specify multiple :paths or :identifiers (can omit keyword :identifiers)
  :Chromes [:identifiers "^org\.chromium\.Chromium$" "^com\.google\.Chrome\.canary$"
            :paths "^/Applications/Google Chrome\.app" "^/Applications/Google Chrome Canary\.app"]

  ;; paths only (can't omit keyword :paths)
  :Chromes [:paths "^/Applications/.*Chrom.*"]}}
```

--------------------------------

### Clojure Configuration for Simultaneous Pointing Button

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/CHANGELOG.org

This Clojure code snippet illustrates a configuration rule for the GokuRakuJoudo project, enabling simultaneous pointing button actions. It defines a mapping where pressing `button5` and `button2` concurrently triggers the action associated with `button1`.

```Clojure
{:des "sim pkey in from"
 :rules [[[{:pkey :button5} {:pkey :button2}] {:pkey :button1}]]}
```

--------------------------------

### Group Karabiner Rules by Conditions (New Method)

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/CHANGELOG.org

This snippet demonstrates the enhanced method for grouping Karabiner rules by conditions. Conditions can now be specified once for a block of rules, reducing redundancy and improving readability. It also shows how to combine group conditions with individual rule conditions.

```clojure
;; now we can group rules with conditions
{:applications {:chromes ["^com\\.google\\.Chrome$"
                          "^org\\.chromium\\.Chromium$"
                          "^com\\.google\\.Chrome\\.canary$"
                          ]}
 :layers {:wlayer {:key :w}
          :xlayer {:key :x}}
 :main [{:des "example layer"
         :rules [:wlayer
                 [:e "open -a Emacs.app"]
                 [:s "open -a Safari.app"]
                 :xlayer
                 [:i "open -a iTunes.app"]

                 ;; support multiple conditions
                 ;; use vector start with :condi for multiple conditions
                 [:condi :xlayer :chromes]
                 [:i "open -a iTunes.app"]

                 ;; you can still spercify conditions as the third element of the rule vector
                 ;; it will be combined with the group condition
                 ;; below rule is same as above one
                 :xlayer
                 [:i "open -a iTunes.app" :chromes]]}]}
```

--------------------------------

### Define Karabiner Layers (Old Method)

Source: https://github.com/yqrashawn/gokurakujoudo/blob/master/CHANGELOG.org

This snippet illustrates the previous method of defining layers in Karabiner configurations. Layers were defined directly within the main configuration block, requiring explicit repetition of layer definitions for each rule.

```clojure
;; before this feature
;; can only define "old" layers like this
{:main [{:des "w layer"
         :rules [[:w ["wlayer" 1] nil {:alone :w :afterup ["wlayer" 0]}]
                 [:e "open -a Emacs.app" :wlayer]
                 [:s "open -a Safari.app" :wlayer]]}]}
```
Tokens:
Raw