.karabiner.edn

{
    ;; I've written extensively about this script/goku/karabiner over at my blog
    ;; You might find this post particularly helpful:
    ;;
    ;;          https://kau.sh/blog/hacking-your-keyboard/
    ;;
    ;; :!Ca is keycode :a and prefix a with !C

    ;; C  | left_command
    ;; T  | left_control
    ;; O  | left_option
    ;; S  | left_shift
    ;; F  | fn
    ;; Q  | right_command
    ;; W  | right_control
    ;; E  | right_option
    ;; R  | right_shift
    ;; P  | caps_lock
    ;; !! | command + control + optional + shift (hyper)

    ;; code for all this:
    ;; https://github.com/yqrashawn/GokuRakuJoudo/blob/b9b334a187379f9bc8182ad59e2cca2a1789e9c0/src/karabiner_configurator/keys.clj#L68

    ;; FROM modifiers
    ;; to understand better how modifiers work in karabiner
    ;; karabiner definition of mandatory and optional
    ;; https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/from/modifiers/

    ;;    | no modifier
    ;;                  input key maps to output key exactly
    ;;                  adding any modifier will cancel the event

    ;; !  | mandatory
    ;;                  specified modifier is removed in output (to event)
    ;;                  specified modifiers must be present for event to occur
    ;;                  adding any other modifier will cancel the event

    ;; #  | optional (single)
    ;;                  specified modifier is kept in output (to event)
    ;;                  one (or none) of the specified modifiers must be present
    ;;                  adding any other modifier will cancel the event

    ;; ## | optional any
    ;;                  specified modifier is removed in output (to event)
    ;;                  specified modifiers *must* be present for event to occur
    ;;                  adding any other modifier will add to output event
    ;;                  (what you typically expect, additional modifiers tacked on)
    ;;
    ;; need to prefix C T O S F with ! or #
    ;;


:profiles {
    :Default {
        :default true

        :sim     25     ;; simultaneous key press threshold (def: 50)
                        ;; simlayer is implemented with to_if_alone and simultaneous key press feature
                        ;; if keydown event for two different keys are pressed within :sim ms, the keypresses are considered simultaneous
        :delay   10    ;; to_delayed_action_delay_milliseconds (def: 500)
                       ;; checkout karabiner's documentation
                       ;; https://pqrs.org/osx/karabiner/json.html
                       ;; basically it means time after which the key press is count delayed

                        ;; after :delay ms, the key press is considered to be delayed
                        ;; (used for double-press macros)
        :alone   250    ;; to_if_alone_timeout_milliseconds (def: 1000)
                        ;; https://pqrs.org/osx/karabiner/json.html#to-if-alone
                        ;; affects to_if_alone behavior
                        ;; simlayer is implemented with to_if_alone and simultaneous key press feature

                        ;; if keyup event comes within :alone ms from keydown, the key is not just pressed but held
        :held    500    ;; to_if_held_down_threshold_milliseconds (def: 500)
                        ;; key is fired twice when :held ms is elapsed (otherwise seen as a hold command) (TODO WHAT IS THIS??)
    }
} ;; profiles

; the default value is 250
:simlayer-threshold 250

:templates {
    :km "osascript -e 'tell application \"Keyboard Maestro Engine\" to do script \"%s\"'"
    :open "open \"%s\""
} ;; templates

;; Define different kinds of keyboards
;; https://karabiner-elements.pqrs.org/docs/json/complex-modifications-manipulator-definition/conditions/device/
:devices {
    :apple [
            {:vendor_id 1452}
            {:vendor_id 76}
            {:is_built_in_keyboard true}
    ]
    :ap2 [{:vendor_id 1241, :product_id 41618 }] ;; Anne Pro 2 (mechanical)
    :msft [{:vendor_id 1118, :product_id 1957 }] ;; Microsoft Keyboard [Ergonomic Sculpt]
    :tada68 [{:vendor_id 65261, :product_id 4611 }] ;; Tada68 (mechanical)
    :kinesis [{:vendor_id 10730 }] ;; Kinesis Advantage 2 keyboard
    :g915   [{:vendor_id 1133}] ;; Logitech G915 keyboard

    :kybs [  ;; Default for all keyboards
        {:vendor_id 1452}
        {:vendor_id 76}
        {:vendor_id 1241, :product_id 41618 }
        {:vendor_id 1118, :product_id 1957 }
        {:vendor_id 65261, :product_id 4611 }
        {:vendor_id 10730}
        {:vendor_id 1133, :product_id 50501 }
    ]

    :kybs-kinesis [  ;; All keyboards (except Kinesis)
        {:vendor_id 1452}
        {:vendor_id 76}
        {:vendor_id 1241, :product_id 41618 }
        {:vendor_id 1118, :product_id 1957 }
        {:vendor_id 65261, :product_id 4611 }
        {:vendor_id 1133, :product_id 50501 }
    ]

} ;; devices

;; layers are basically "hyper" keys
;; press this in combination with something else and depending on your rule, make things happen
:layers {
;;    :tab-mode   {:key :tab}
;;     :caps-mode {:key :caps_lock :alone {:key :escape}}
} ;; layers

;; simlayers are basically "hyper" keys
;; layers works too, but only recommended for non-typing keys like . or tab
;; to use more regular typing keys, use simlayers
:simlayers {
  :j-mode {:key :j}
  :f-mode {:key :f}
} ;; simlayers

:applications {
    :terminals  [ "^com\\.apple\\.Terminal$",
                 "^com\\.googlecode\\.iterm2$"]
    :intellij   [ "com.google.android.studio",
                 "^com\\.jetbrains\\..*$"]
}

;; main contains multiple manipulators
:main [

    ;; each manipulator has a description and multiple rules

    ;;{:des "..."                               ;; -> description
    ;; :rules[
    ;;          [<from>  <to>  <conditions>]    ;; -> rule 1
    ;;          [<from>  <to>  <conditions>]    ;; -> rule 2
    ;; ]}

    ;; rule [:period ["period-mode" 1] nil {:afterup ["period-mode" 0] :alone :period}]
    ;;       |_____| |_______________| |_| |_________________________________________|
    ;;        <from>    <to>      <conditions>         <other options>
    ;;
    ;; karabiner docs: ;; https://pqrs.org/osx/karabiner/json.html#complex_modifications-manipulator-definition
    ;; <other options> includs ~to_if_alone~, ~to_if_held_down~,~to_after_key_up~, ~to_delayed_action~ and ~parameters~.
    ;;

    ;; (custom variables) & modifiers -> Advanced
    ;; https://github.com/yqrashawn/GokuRakuJoudo/blob/master/examples.org#custom-variable

    ;; ----------------------------------
    ;; Hardware keyboard mappings
    ;; ----------------------------------

;;    {:des "Anne Pro 2"
;;     :rules [:ap2
;;       [:left_option :left_command]
;;       [:left_command :left_option]
;;       [:right_option :right_control]
;;    ]}
;;    {:des "Tada68 specific mappings"
;;     :rules [:tada68
;;       [:delete_forward :end]
;;       [:escape :grave_accent_and_tilde]
;;       [:grave_accent_and_tilde :home]
;;       [:left_gui :left_alt]
;;    ]}
;;
;;    {:des "Microsoft Ergonomic Sculpt Keyboard"
;;     :rules [:msft
;;       [:delete_forward :end]
;;       [:escape :grave_accent_and_tilde]
;;       [:grave_accent_and_tilde :home]
;;       [:left_gui :left_alt]
;;    ]}
;;
;;    {:des "Logitech G915 remap"
;;     :rules [:g915
;;       [:##right_option :right_control]
;;       [:##left_option :left_command]
;;       [:##left_command :left_option]
;;    ]}

    {:des "Kinesis Advantage2 specific mappings"
     :rules [:kinesis
       [:non_us_backslash :!QWspacebar] ;; § -> emoji viewer
       [:open_bracket :backslash] ;; [ -> \
       [:close_bracket :slash] ;; ] -> /
    ]}


    ;; ----------------------------------
    ;; ----------------------------------
    ;; Key mappings
    ;; ----------------------------------
    ;; ----------------------------------

    {:des "Right Cmd (alone) -> Enter"
     :rules [ :apple
        [:##right_command :right_control nil {:alone [:return_or_enter]}]
    ]}


       ;; -----------------------------------------
       ;; caps-mode
       ;; -----------------------------------------


     {:des "Caps Lock -> Escape (alone) | Ctrl (simple)"
      :rules [
          [:##caps_lock :right_control nil {:alone [:escape]}]

          ;; P  | caps_lock
          ;; W  | right_control

          ;; C  | left_command
          ;; Q  | right_command

          ;; E  | right_option
          ;; O  | left_option

          ;; R  | right_shift
          ;; S  | left_shift


          ;; vim like arrow key mappings
          [:!Wh :left_arrow]
          [:!Wj :down_arrow]
          [:!Wk :up_arrow  ]
          [:!Wl :right_arrow]

          ;; Modifier + arrow keys
          ;; triggering them with caps-lock requires explicit mapping

          ;; (W) left_command + arrow keys
          [:!WCh :!Cleft_arrow]
          [:!WCj :!Cdown_arrow]
          [:!WCk :!Cup_arrow  ]
          [:!WCl :!Cright_arrow]

          ;; (W) left_shift + arrow keys
          [:!WSh :!Sleft_arrow]
          [:!WSl :!Sright_arrow]
          [:!WSh :!Sleft_arrow]
          [:!WSk :!Sup_arrow  ]
          [:!WSj :!Sdown_arrow  :!intellij]
          [:!WSj :!TSj          :intellij]     ;; special for intellij (join line)

          ;; (W) left_option + arrow keys
          [:!WOh :!Oleft_arrow]
          [:!WOj :!Odown_arrow]
          [:!WOk :!Oup_arrow  ]
          [:!WOl :!Oright_arrow]

          ;; (W) left_command + left_option + arrow keys
          [:!WCOh :!COleft_arrow]
          [:!WCOj :!COdown_arrow]
          [:!WCOk :!COup_arrow  ]
          [:!WCOl :!COright_arrow]

          ;; (W) left_command + left_shift + arrow keys
          [:!WSCh :!SCleft_arrow]
          [:!WSCj :!SCdown_arrow]
          [:!WSCk :!SCup_arrow  ]
          [:!WSCl :!SCright_arrow]


          ;; Quick Mouse handles
          [:!Wdown_arrow {:mkey {:y 1536}}     ]
          [:!Wup_arrow {:mkey {:y -1536}}      ]
          [:!Wleft_arrow {:mkey {:x -1536}}    ]
          [:!Wright_arrow {:mkey {:x 1536}}    ]
          [:!Wreturn_or_enter {:pkey :button1} ]
          [:!CWreturn_or_enter {:pkey :button2}]
      ]}

     ;;     {:des "Caps Lock -> Escape | Ctrl | Vim movements | Mouse movement"
     ;;         :rules [ :caps-mode
     ;;
     ;;           ;[:caps_lock ["caps-mode" 1] nil {:afterup ["caps-mode" 0] :alone :escape}]
     ;;           ; [:h :left_arrow ["caps-mode" 1]]
     ;;
     ;;           ;; caps lock : arrow mode
     ;;           [:h :left_arrow]
     ;;           [:j :down_arrow]
     ;;           [:k :up_arrow  ]
     ;;           [:l :right_arrow]
     ;;
     ;;           ;; Quick Mouse handles
     ;;           [:down_arrow {:mkey {:y 1536}}     ]
     ;;           [:up_arrow {:mkey {:y -1536}}      ]
     ;;           [:left_arrow {:mkey {:x -1536}}    ]
     ;;           [:right_arrow {:mkey {:x 1536}}    ]
     ;;           [:return_or_enter {:pkey :button1} ]
     ;;           [:!Creturn_or_enter {:pkey :button2}]
     ;;
     ;;           ;; Ctrl handles
     ;;           [:!Sj [:!TSj]]                                    ;; Ctrl Shift J
     ;;
     ;;           [:a [:!Ta]]                                      ;; Ctrl a
     ;;           [:b [:!Tb]]                                      ;; Ctrl b
     ;;           [:c [:!Tc]]                                      ;; Ctrl c
     ;;           [:d [:!Td]]                                      ;; Ctrl d
     ;;           [:e [:!Te]]                                      ;; Ctrl e
     ;;           [:f [:!Tf]]                                      ;; Ctrl f
     ;;           [:g [:!Tg]]                                      ;; Ctrl g
     ;;           [:i [:!Ti]]                                      ;; Ctrl i
     ;;           [:m [:!Tm]]                                      ;; Ctrl m
     ;;           [:n [:!Tn]]                                      ;; Ctrl n
     ;;           [:o [:!To]]                                      ;; Ctrl o
     ;;           [:p [:!Tp]]                                      ;; Ctrl p
     ;;           [:q [:!Tq]]                                      ;; Ctrl q
     ;;           [:r [:!Tr]]                                      ;; Ctrl r
     ;;           [:s [:!Ts]]                                      ;; Ctrl s
     ;;           [:t [:!Tt]]                                      ;; Ctrl t
     ;;           [:u [:!Tu]]                                      ;; Ctrl u
     ;;           [:v [:!Tv]]                                      ;; Ctrl v
     ;;           [:w [:!Tw]]                                      ;; Ctrl w
     ;;           [:x [:!Tx]]                                      ;; Ctrl x
     ;;           [:y [:!Ty]]                                      ;; Ctrl y
     ;;           [:z [:!Tz]]                                      ;; Ctrl z
     ;;   ]}


       ;; -----------------------------------------
      ;; j-mode (deletion related shortcuts)
      ;; -----------------------------------------

      {:des "j-mode (deletion related shortcuts)"
       :rules [:j-mode

          ;;  s d f  ||| line word char

          ;; delete line
          [:s :!Tu                    :terminals]
          [:s :!Cdelete_or_backspace  :!terminals]

          ;; delete word
          [:d :!Tw                    :terminals]
          [:d :!Odelete_or_backspace  :!terminals]

          ;; delete char | backspace
          [:f :delete_or_backspace]

          ;; Command + {} move next/prev tag
          [:l           :!CSopen_bracket ]
          [:semicolon   :!CSclose_bracket]
      ]}

      ;; -----------------------------------------
      ;; f-mode (special characters)
      ;; -----------------------------------------
      {:des "f-mode (special characters) ... mostly"
          :rules [

            ;;  u i o p
            ;;  - + = *
            [:u    :hyphen          :f-mode]
            [:i    :!Sequal_sign    :f-mode]
            [:o    :equal_sign      :f-mode]
            [:p    :!S8             :f-mode]


            ;; m ,
            ;; [ ]
            [:m     :open_bracket   :f-mode]
            [:comma     :close_bracket  :f-mode]
;;             [:j     :open_bracket   :f-mode]
;;             [:k     :close_bracket  :f-mode]

            ;; j k
            ;; ( )
;;             [:m       :!S9   :f-mode]
;;             [:comma   :!S0   :f-mode]
            [:j       :!S9   :f-mode]
            [:k   :!S0   :f-mode]

            ;; . /
            ;; { }
            [:period  :!Sopen_bracket   :f-mode]
            [:slash   :!Sclose_bracket   :f-mode]


            ; ;
            ; ,
            ; this is helpful in vim (find forward / find backward)
            [:semicolon  :comma   :f-mode]


      ]}


;    {:des "testing"
;        :rules [
;          ;; [{:pkey :button2 :modi :any :lazy true} :left_arrow]
;          ;; Alt -> Hyper
;          ;; [:##right_alt :!QWEright_shift]

;          ;; easier reach to modifier keys
;          ;;[:##slash :right_command  nil {:alone :slash}]
;          ;; [:##z     :left_control   nil {:alone :z}]

;          ;; easier key launches
;          ;;[[:f :j] :!Ospacebar] ;; alfred

;          ;; Alt -> [] or Meh(Control Shift Option): secondary thumb keys
;          ;; [:right_alt :!CTOleft_shift :apple]
;          ;; [:##application :!TOleft_shift :g915]
;          ; [:##left_control :!TOleft_shift :apple]

;          ;; {}
;          ;; [:comma       :!Sopen_bracket     :d-mode]
;          ;; [:period      :!Sclose_bracket    :d-mode]
;          ;[:left_shift    :left_shift   nil   {:alone :!Sopen_bracket }]
;          ;[:right_shift   :right_shift  nil   {:alone :!Sclose_bracket }]
;          ;[:##left_option   :left_command  :g915  {:alone :!S9 }]
;          ;[:##right_option  :right_control :g915  {:alone :!S0 }]

    ;;     ;; "close application by pressing command-w twice"
    ;;     [:!C#Pw [:!Cw ["command-w" 0] [:noti :cmdw]] ["command-w" 1]]
    ;;     [:!C#Pw [[:noti :cmdw "Press Again to CLOSE"] ["command-w" 1]] nil {:delayed {:invoked [["command-w" 0] [:noti :cmdw]] :canceled [["command-w" 0] [:noti :cmdw]]}} ]
;        ]


          ;; k → {
            ;; kk → }
;        :rules [:f-mode
;          [
;            :k
;            [:!Sclose_bracket ["dmode-curlyb" 0]]
;            ["dmode-curlyb" 1]
;          ]
;
;          [
;            :k
;            [["dmode-curlyb" 1]]
;            nil
;            {
;            :delayed
;                {
;                      :invoked  [["dmode-curlyb" 0] :!Sopen_bracket]
;                      :canceled [["dmode-curlyb" 0]]
;                }
;            }
;          ]

;          [:k [:km "trigger macro by name"] ] ;; keyboard maestro

;          ; training wheels
;          [:delete_or_backspace     :vk_none]

;        ]
;    }


    ;; {:des "Confirm destructive actions like quit/close twice"
    ;;  :rules [
    ;;     ;; full explanation for how this works
    ;;     ;; https://github.com/yqrashawn/GokuRakuJoudo/blob/a77cccb8e8d4e6a9fb8ef2e6bcfe49a4299e4cb2/examples.org#command-q-twice-to-quit-application

    ;;     [
    ;;       ;; <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]]
    ;;           }
    ;;       }
    ;;     ]
    ;; ]}


] ;; main list

}