nixos/modules/i18n/input-method/default.md

   1 # Input Methods {#module-services-input-methods}
   2
   3 Input methods are an operating system component that allows any data, such as
   4 keyboard strokes or mouse movements, to be received as input. In this way
   5 users can enter characters and symbols not found on their input devices.
   6 Using an input method is obligatory for any language that has more graphemes
   7 than there are keys on the keyboard.
   8
   9 The following input methods are available in NixOS:
  10
  11   - IBus: The intelligent input bus.
  12   - Fcitx5: The next generation of fcitx, addons (including engines, dictionaries, skins) can be added using `i18n.inputMethod.fcitx5.addons`.
  13   - Nabi: A Korean input method based on XIM.
  14   - Uim: The universal input method, is a library with a XIM bridge.
  15   - Hime: An extremely easy-to-use input method framework.
  16   - Kime: Korean IME
  17
  18 ## IBus {#module-services-input-methods-ibus}
  19
  20 IBus is an Intelligent Input Bus. It provides full featured and user
  21 friendly input method user interface.
  22
  23 The following snippet can be used to configure IBus:
  24
  25 ```nix
  26 {
  27   i18n.inputMethod = {
  28     enable = true;
  29     type = "ibus";
  30     ibus.engines = with pkgs.ibus-engines; [ anthy hangul mozc ];
  31   };
  32 }
  33 ```
  34
  35 `i18n.inputMethod.ibus.engines` is optional and can be used
  36 to add extra IBus engines.
  37
  38 Available extra IBus engines are:
  39
  40   - Anthy (`ibus-engines.anthy`): Anthy is a system for
  41     Japanese input method. It converts Hiragana text to Kana Kanji mixed text.
  42   - Hangul (`ibus-engines.hangul`): Korean input method.
  43   - libpinyin (`ibus-engines.libpinyin`): A Chinese input method.
  44   - m17n (`ibus-engines.m17n`): m17n is an input method that
  45     uses input methods and corresponding icons in the m17n database.
  46   - mozc (`ibus-engines.mozc`): A Japanese input method from
  47     Google.
  48   - Table (`ibus-engines.table`): An input method that load
  49     tables of input methods.
  50   - table-others (`ibus-engines.table-others`): Various
  51     table-based input methods. To use this, and any other table-based input
  52     methods, it must appear in the list of engines along with
  53     `table`. For example:
  54
  55     ```nix
  56     {
  57       ibus.engines = with pkgs.ibus-engines; [ table table-others ];
  58     }
  59     ```
  60
  61 To use any input method, the package must be added in the configuration, as
  62 shown above, and also (after running `nixos-rebuild`) the
  63 input method must be added from IBus' preference dialog.
  64
  65 ### Troubleshooting {#module-services-input-methods-troubleshooting}
  66
  67 If IBus works in some applications but not others, a likely cause of this
  68 is that IBus is depending on a different version of `glib`
  69 to what the applications are depending on. This can be checked by running
  70 `nix-store -q --requisites <path> | grep glib`,
  71 where `<path>` is the path of either IBus or an
  72 application in the Nix store. The `glib` packages must
  73 match exactly. If they do not, uninstalling and reinstalling the
  74 application is a likely fix.
  75
  76 ## Fcitx5 {#module-services-input-methods-fcitx}
  77
  78 Fcitx5 is an input method framework with extension support. It has three
  79 built-in Input Method Engine, Pinyin, QuWei and Table-based input methods.
  80
  81 The following snippet can be used to configure Fcitx:
  82
  83 ```nix
  84 {
  85   i18n.inputMethod = {
  86     enable = true;
  87     type = "fcitx5";
  88     fcitx5.addons = with pkgs; [ fcitx5-mozc fcitx5-hangul fcitx5-m17n ];
  89   };
  90 }
  91 ```
  92
  93 `i18n.inputMethod.fcitx5.addons` is optional and can be
  94 used to add extra Fcitx5 addons.
  95
  96 Available extra Fcitx5 addons are:
  97
  98   - Anthy (`fcitx5-anthy`): Anthy is a system for
  99     Japanese input method. It converts Hiragana text to Kana Kanji mixed text.
 100   - Chewing (`fcitx5-chewing`): Chewing is an
 101     intelligent Zhuyin input method. It is one of the most popular input
 102     methods among Traditional Chinese Unix users.
 103   - Hangul (`fcitx5-hangul`): Korean input method.
 104   - Unikey (`fcitx5-unikey`): Vietnamese input method.
 105   - m17n (`fcitx5-m17n`): m17n is an input method that
 106     uses input methods and corresponding icons in the m17n database.
 107   - mozc (`fcitx5-mozc`): A Japanese input method from
 108     Google.
 109   - table-others (`fcitx5-table-other`): Various
 110     table-based input methods.
 111   - chinese-addons (`fcitx5-chinese-addons`): Various chinese input methods.
 112   - rime (`fcitx5-rime`): RIME support for fcitx5.
 113
 114 ## Nabi {#module-services-input-methods-nabi}
 115
 116 Nabi is an easy to use Korean X input method. It allows you to enter
 117 phonetic Korean characters (hangul) and pictographic Korean characters
 118 (hanja).
 119
 120 The following snippet can be used to configure Nabi:
 121
 122 ```nix
 123 {
 124   i18n.inputMethod = {
 125     enable = true;
 126     type = "nabi";
 127   };
 128 }
 129 ```
 130
 131 ## Uim {#module-services-input-methods-uim}
 132
 133 Uim (short for "universal input method") is a multilingual input method
 134 framework. Applications can use it through so-called bridges.
 135
 136 The following snippet can be used to configure uim:
 137
 138 ```nix
 139 {
 140   i18n.inputMethod = {
 141     enable = true;
 142     type = "uim";
 143   };
 144 }
 145 ```
 146
 147 Note: The [](#opt-i18n.inputMethod.uim.toolbar) option can be
 148 used to choose uim toolbar.
 149
 150 ## Hime {#module-services-input-methods-hime}
 151
 152 Hime is an extremely easy-to-use input method framework. It is lightweight,
 153 stable, powerful and supports many commonly used input methods, including
 154 Cangjie, Zhuyin, Dayi, Rank, Shrimp, Greek, Korean Pinyin, Latin Alphabet,
 155 etc...
 156
 157 The following snippet can be used to configure Hime:
 158
 159 ```nix
 160 {
 161   i18n.inputMethod = {
 162     enable = true;
 163     type = "hime";
 164   };
 165 }
 166 ```
 167
 168 ## Kime {#module-services-input-methods-kime}
 169
 170 Kime is Korean IME. it's built with Rust language and let you get simple, safe, fast Korean typing
 171
 172 The following snippet can be used to configure Kime:
 173
 174 ```nix
 175 {
 176   i18n.inputMethod = {
 177     enable = true;
 178     type = "kime";
 179   };
 180 }
 181 ```