Skip to content
BranchesTags

Repository files navigation

KeyboardKit

The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.

Keyboard control is a standard expectation of Mac apps. It’s important on iOS too because a hardware keyboard improves speed and ergonomics, which makes an iPad an even more powerful productivity machine.

KeyboardKit is designed to integrate with the UIKit focus system when available (iPad with iOS 15+, macOS 11+), and it provides similar arrow and tab key navigation on OS versions where the focus system is not available (iPhone, iPad with iOS 13–14, macOS 10.15).

Features

Requirements

Xcode 14.1 or later is required. KeyboardKit supports iOS 13 onwards on iPad and iPhone and macOS 11 onwards with Mac Catalyst (both scaled and optimised). tvOS is not supported. The framework builds for visionOS, but this platform has not been tested.

Installation

Swift Package Manager

Add KeyboardKit to an existing Xcode project as a package dependency:

  1. Navigate to your project settings and then the Package Dependencies tab.
  2. Click the + button.
  3. Enter https://github.com/douglashill/KeyboardKit into the search or package URL field.

Direct

  1. Clone this repository.
  2. Drag KeyboardKit.xcodeproj into your Xcode project.
  3. Add the KeyboardKit target as a dependency of your target.
  4. Add KeyboardKit.framework to your target as an embedded framework.

Swift Package Manager requires the Swift and Objective-C sources to be separated into modules. The KeyboardKitObjC module is used internally by KeyboardKit and does not need to be imported explicitly by your app.

CocoaPods (legacy)

Up until version 8.2.0, KeyboardKit was available on CocoaPods as Keyboard-Kit. Please use Swift Package Manager or direct installation instead.

Usage

Import the framework:

import KeyboardKit

UIKit

Instead of creating or subclassing a UIKit class directly, use the subclasses from KeyboardKit instead. All KeyboardKit subclasses are named by changing UI to Keyboard. For example replace

classSettingsViewController:UICollectionViewController{...}

with

classSettingsViewController:KeyboardCollectionViewController{...}

Or create KeyboardKit subclasses directly:

lettabBarController=KeyboardTabBarController()
tabBarController.viewControllers =[KeyboardNavigationController(rootViewController:SettingsViewController()),]

In order to receive key commands, an object must be on the responder chain.

You can see more in the KeyboardKitDemo app, and each class includes API documentation in their Swift source file.

SwiftUI

When using the .keyboardShortcut modifier on a Button, access semantically defined KeyboardShortcuts for common actions within the .KeyboardKit namespace:

Button("Save"){
// Save something here in the button action
}.keyboardShortcut(.KeyboardKit.save)

This adds the ability trigger the action of the button by pressing ⌘S.

Learn more

Credits

KeyboardKit is a project from Douglas Hill with the generous help of contributors. Some concepts were originally developed for PSPDFKit and reimplemented in Swift for KeyboardKit. I use KeyboardKit in my reading app.

Contributing

I’d love to have help on this project. For small changes please open a pull request; for larger changes please open an issue first to discuss what you’d like to see.

Tests are not required for new functionality, but fixed regressions should have automated tests. Use KeyboardKitTests for unit tests that don’t need views or a responder chain. Use KeyboardKitDemoUITests for integration tests that can be reproduced in the demo app. This only works on Mac Catalyst currently because iOS does not allow simulating hardware keyboard input. Use KeyboardKitUITests for any test cases between, which is probably most cases.

Licence

MIT license — see License.txt

About

The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.

Resources

Readme
MIT license
Activity

Stars

456 stars

Watchers

5 watching

Forks

13 forks
Report repository

Releases

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - douglashill/KeyboardKit: The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app. · GitHub
Skip to content
BranchesTags
Repository files navigation
KeyboardKit
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Keyboard control is a standard expectation of Mac apps. It’s important on iOS too because a hardware keyboard improves speed and ergonomics, which makes an iPad an even more powerful productivity machine.
KeyboardKit is designed to integrate with the UIKit focus system when available (iPad with iOS 15+, macOS 11+), and it provides similar arrow and tab key navigation on OS versions where the focus system is not available (iPhone, iPad with iOS 13–14, macOS 10.15).
Features
Requirements
Xcode 14.1 or later is required. KeyboardKit supports iOS 13 onwards on iPad and iPhone and macOS 11 onwards with Mac Catalyst (both scaled and optimised). tvOS is not supported. The framework builds for visionOS, but this platform has not been tested.
Installation
Swift Package Manager
Add KeyboardKit to an existing Xcode project as a package dependency:
  1. Navigate to your project settings and then the Package Dependencies tab.
  2. Click the + button.
  3. Enter https://github.com/douglashill/KeyboardKit into the search or package URL field.
Direct
  1. Clone this repository.
  2. Drag KeyboardKit.xcodeproj into your Xcode project.
  3. Add the KeyboardKit target as a dependency of your target.
  4. Add KeyboardKit.framework to your target as an embedded framework.
Swift Package Manager requires the Swift and Objective-C sources to be separated into modules. The KeyboardKitObjC module is used internally by KeyboardKit and does not need to be imported explicitly by your app.
CocoaPods (legacy)
Up until version 8.2.0, KeyboardKit was available on CocoaPods as Keyboard-Kit. Please use Swift Package Manager or direct installation instead.
Usage
Import the framework:
import KeyboardKit
UIKit
Instead of creating or subclassing a UIKit class directly, use the subclasses from KeyboardKit instead. All KeyboardKit subclasses are named by changing UI to Keyboard. For example replace
classSettingsViewController:UICollectionViewController{...}
with
classSettingsViewController:KeyboardCollectionViewController{...}
Or create KeyboardKit subclasses directly:
lettabBarController=KeyboardTabBarController()
tabBarController.viewControllers =[KeyboardNavigationController(rootViewController:SettingsViewController()),]
In order to receive key commands, an object must be on the responder chain.
You can see more in the KeyboardKitDemo app, and each class includes API documentation in their Swift source file.
SwiftUI
When using the .keyboardShortcut modifier on a Button, access semantically defined KeyboardShortcuts for common actions within the .KeyboardKit namespace:
Button("Save"){
// Save something here in the button action
}.keyboardShortcut(.KeyboardKit.save)
This adds the ability trigger the action of the button by pressing ⌘S.
Learn more
Credits
KeyboardKit is a project from Douglas Hill with the generous help of contributors. Some concepts were originally developed for PSPDFKit and reimplemented in Swift for KeyboardKit. I use KeyboardKit in my reading app.
Contributing
I’d love to have help on this project. For small changes please open a pull request; for larger changes please open an issue first to discuss what you’d like to see.
Tests are not required for new functionality, but fixed regressions should have automated tests. Use KeyboardKitTests for unit tests that don’t need views or a responder chain. Use KeyboardKitDemoUITests for integration tests that can be reproduced in the demo app. This only works on Mac Catalyst currently because iOS does not allow simulating hardware keyboard input. Use KeyboardKitUITests for any test cases between, which is probably most cases.
Licence
MIT license — see License.txt
About
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Resources
Readme
MIT license
Activity
Stars
456 stars
Watchers
5 watching
Forks
13 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - douglashill/KeyboardKit: The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app. · GitHub
Skip to content
BranchesTags
Repository files navigation
KeyboardKit
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Keyboard control is a standard expectation of Mac apps. It’s important on iOS too because a hardware keyboard improves speed and ergonomics, which makes an iPad an even more powerful productivity machine.
KeyboardKit is designed to integrate with the UIKit focus system when available (iPad with iOS 15+, macOS 11+), and it provides similar arrow and tab key navigation on OS versions where the focus system is not available (iPhone, iPad with iOS 13–14, macOS 10.15).
Features
Requirements
Xcode 14.1 or later is required. KeyboardKit supports iOS 13 onwards on iPad and iPhone and macOS 11 onwards with Mac Catalyst (both scaled and optimised). tvOS is not supported. The framework builds for visionOS, but this platform has not been tested.
Installation
Swift Package Manager
Add KeyboardKit to an existing Xcode project as a package dependency:
  1. Navigate to your project settings and then the Package Dependencies tab.
  2. Click the + button.
  3. Enter https://github.com/douglashill/KeyboardKit into the search or package URL field.
Direct
  1. Clone this repository.
  2. Drag KeyboardKit.xcodeproj into your Xcode project.
  3. Add the KeyboardKit target as a dependency of your target.
  4. Add KeyboardKit.framework to your target as an embedded framework.
Swift Package Manager requires the Swift and Objective-C sources to be separated into modules. The KeyboardKitObjC module is used internally by KeyboardKit and does not need to be imported explicitly by your app.
CocoaPods (legacy)
Up until version 8.2.0, KeyboardKit was available on CocoaPods as Keyboard-Kit. Please use Swift Package Manager or direct installation instead.
Usage
Import the framework:
import KeyboardKit
UIKit
Instead of creating or subclassing a UIKit class directly, use the subclasses from KeyboardKit instead. All KeyboardKit subclasses are named by changing UI to Keyboard. For example replace
classSettingsViewController:UICollectionViewController{...}
with
classSettingsViewController:KeyboardCollectionViewController{...}
Or create KeyboardKit subclasses directly:
lettabBarController=KeyboardTabBarController()
tabBarController.viewControllers =[KeyboardNavigationController(rootViewController:SettingsViewController()),]
In order to receive key commands, an object must be on the responder chain.
You can see more in the KeyboardKitDemo app, and each class includes API documentation in their Swift source file.
SwiftUI
When using the .keyboardShortcut modifier on a Button, access semantically defined KeyboardShortcuts for common actions within the .KeyboardKit namespace:
Button("Save"){
// Save something here in the button action
}.keyboardShortcut(.KeyboardKit.save)
This adds the ability trigger the action of the button by pressing ⌘S.
Learn more
Credits
KeyboardKit is a project from Douglas Hill with the generous help of contributors. Some concepts were originally developed for PSPDFKit and reimplemented in Swift for KeyboardKit. I use KeyboardKit in my reading app.
Contributing
I’d love to have help on this project. For small changes please open a pull request; for larger changes please open an issue first to discuss what you’d like to see.
Tests are not required for new functionality, but fixed regressions should have automated tests. Use KeyboardKitTests for unit tests that don’t need views or a responder chain. Use KeyboardKitDemoUITests for integration tests that can be reproduced in the demo app. This only works on Mac Catalyst currently because iOS does not allow simulating hardware keyboard input. Use KeyboardKitUITests for any test cases between, which is probably most cases.
Licence
MIT license — see License.txt
About
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Resources
Readme
MIT license
Activity
Stars
456 stars
Watchers
5 watching
Forks
13 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - douglashill/KeyboardKit: The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app. · GitHub
Skip to content
BranchesTags
Repository files navigation
KeyboardKit
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Keyboard control is a standard expectation of Mac apps. It’s important on iOS too because a hardware keyboard improves speed and ergonomics, which makes an iPad an even more powerful productivity machine.
KeyboardKit is designed to integrate with the UIKit focus system when available (iPad with iOS 15+, macOS 11+), and it provides similar arrow and tab key navigation on OS versions where the focus system is not available (iPhone, iPad with iOS 13–14, macOS 10.15).
Features
Requirements
Xcode 14.1 or later is required. KeyboardKit supports iOS 13 onwards on iPad and iPhone and macOS 11 onwards with Mac Catalyst (both scaled and optimised). tvOS is not supported. The framework builds for visionOS, but this platform has not been tested.
Installation
Swift Package Manager
Add KeyboardKit to an existing Xcode project as a package dependency:
  1. Navigate to your project settings and then the Package Dependencies tab.
  2. Click the + button.
  3. Enter https://github.com/douglashill/KeyboardKit into the search or package URL field.
Direct
  1. Clone this repository.
  2. Drag KeyboardKit.xcodeproj into your Xcode project.
  3. Add the KeyboardKit target as a dependency of your target.
  4. Add KeyboardKit.framework to your target as an embedded framework.
Swift Package Manager requires the Swift and Objective-C sources to be separated into modules. The KeyboardKitObjC module is used internally by KeyboardKit and does not need to be imported explicitly by your app.
CocoaPods (legacy)
Up until version 8.2.0, KeyboardKit was available on CocoaPods as Keyboard-Kit. Please use Swift Package Manager or direct installation instead.
Usage
Import the framework:
import KeyboardKit
UIKit
Instead of creating or subclassing a UIKit class directly, use the subclasses from KeyboardKit instead. All KeyboardKit subclasses are named by changing UI to Keyboard. For example replace
classSettingsViewController:UICollectionViewController{...}
with
classSettingsViewController:KeyboardCollectionViewController{...}
Or create KeyboardKit subclasses directly:
lettabBarController=KeyboardTabBarController()
tabBarController.viewControllers =[KeyboardNavigationController(rootViewController:SettingsViewController()),]
In order to receive key commands, an object must be on the responder chain.
You can see more in the KeyboardKitDemo app, and each class includes API documentation in their Swift source file.
SwiftUI
When using the .keyboardShortcut modifier on a Button, access semantically defined KeyboardShortcuts for common actions within the .KeyboardKit namespace:
Button("Save"){
// Save something here in the button action
}.keyboardShortcut(.KeyboardKit.save)
This adds the ability trigger the action of the button by pressing ⌘S.
Learn more
Credits
KeyboardKit is a project from Douglas Hill with the generous help of contributors. Some concepts were originally developed for PSPDFKit and reimplemented in Swift for KeyboardKit. I use KeyboardKit in my reading app.
Contributing
I’d love to have help on this project. For small changes please open a pull request; for larger changes please open an issue first to discuss what you’d like to see.
Tests are not required for new functionality, but fixed regressions should have automated tests. Use KeyboardKitTests for unit tests that don’t need views or a responder chain. Use KeyboardKitDemoUITests for integration tests that can be reproduced in the demo app. This only works on Mac Catalyst currently because iOS does not allow simulating hardware keyboard input. Use KeyboardKitUITests for any test cases between, which is probably most cases.
Licence
MIT license — see License.txt
About
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Resources
Readme
MIT license
Activity
Stars
456 stars
Watchers
5 watching
Forks
13 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - douglashill/KeyboardKit: The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app. · GitHub
Skip to content
BranchesTags
Repository files navigation
KeyboardKit
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Keyboard control is a standard expectation of Mac apps. It’s important on iOS too because a hardware keyboard improves speed and ergonomics, which makes an iPad an even more powerful productivity machine.
KeyboardKit is designed to integrate with the UIKit focus system when available (iPad with iOS 15+, macOS 11+), and it provides similar arrow and tab key navigation on OS versions where the focus system is not available (iPhone, iPad with iOS 13–14, macOS 10.15).
Features
Requirements
Xcode 14.1 or later is required. KeyboardKit supports iOS 13 onwards on iPad and iPhone and macOS 11 onwards with Mac Catalyst (both scaled and optimised). tvOS is not supported. The framework builds for visionOS, but this platform has not been tested.
Installation
Swift Package Manager
Add KeyboardKit to an existing Xcode project as a package dependency:
  1. Navigate to your project settings and then the Package Dependencies tab.
  2. Click the + button.
  3. Enter https://github.com/douglashill/KeyboardKit into the search or package URL field.
Direct
  1. Clone this repository.
  2. Drag KeyboardKit.xcodeproj into your Xcode project.
  3. Add the KeyboardKit target as a dependency of your target.
  4. Add KeyboardKit.framework to your target as an embedded framework.
Swift Package Manager requires the Swift and Objective-C sources to be separated into modules. The KeyboardKitObjC module is used internally by KeyboardKit and does not need to be imported explicitly by your app.
CocoaPods (legacy)
Up until version 8.2.0, KeyboardKit was available on CocoaPods as Keyboard-Kit. Please use Swift Package Manager or direct installation instead.
Usage
Import the framework:
import KeyboardKit
UIKit
Instead of creating or subclassing a UIKit class directly, use the subclasses from KeyboardKit instead. All KeyboardKit subclasses are named by changing UI to Keyboard. For example replace
classSettingsViewController:UICollectionViewController{...}
with
classSettingsViewController:KeyboardCollectionViewController{...}
Or create KeyboardKit subclasses directly:
lettabBarController=KeyboardTabBarController()
tabBarController.viewControllers =[KeyboardNavigationController(rootViewController:SettingsViewController()),]
In order to receive key commands, an object must be on the responder chain.
You can see more in the KeyboardKitDemo app, and each class includes API documentation in their Swift source file.
SwiftUI
When using the .keyboardShortcut modifier on a Button, access semantically defined KeyboardShortcuts for common actions within the .KeyboardKit namespace:
Button("Save"){
// Save something here in the button action
}.keyboardShortcut(.KeyboardKit.save)
This adds the ability trigger the action of the button by pressing ⌘S.
Learn more
Credits
KeyboardKit is a project from Douglas Hill with the generous help of contributors. Some concepts were originally developed for PSPDFKit and reimplemented in Swift for KeyboardKit. I use KeyboardKit in my reading app.
Contributing
I’d love to have help on this project. For small changes please open a pull request; for larger changes please open an issue first to discuss what you’d like to see.
Tests are not required for new functionality, but fixed regressions should have automated tests. Use KeyboardKitTests for unit tests that don’t need views or a responder chain. Use KeyboardKitDemoUITests for integration tests that can be reproduced in the demo app. This only works on Mac Catalyst currently because iOS does not allow simulating hardware keyboard input. Use KeyboardKitUITests for any test cases between, which is probably most cases.
Licence
MIT license — see License.txt
About
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Resources
Readme
MIT license
Activity
Stars
456 stars
Watchers
5 watching
Forks
13 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - douglashill/KeyboardKit: The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app. · GitHub
Skip to content
BranchesTags
Repository files navigation
KeyboardKit
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Keyboard control is a standard expectation of Mac apps. It’s important on iOS too because a hardware keyboard improves speed and ergonomics, which makes an iPad an even more powerful productivity machine.
KeyboardKit is designed to integrate with the UIKit focus system when available (iPad with iOS 15+, macOS 11+), and it provides similar arrow and tab key navigation on OS versions where the focus system is not available (iPhone, iPad with iOS 13–14, macOS 10.15).
Features
Requirements
Xcode 14.1 or later is required. KeyboardKit supports iOS 13 onwards on iPad and iPhone and macOS 11 onwards with Mac Catalyst (both scaled and optimised). tvOS is not supported. The framework builds for visionOS, but this platform has not been tested.
Installation
Swift Package Manager
Add KeyboardKit to an existing Xcode project as a package dependency:
  1. Navigate to your project settings and then the Package Dependencies tab.
  2. Click the + button.
  3. Enter https://github.com/douglashill/KeyboardKit into the search or package URL field.
Direct
  1. Clone this repository.
  2. Drag KeyboardKit.xcodeproj into your Xcode project.
  3. Add the KeyboardKit target as a dependency of your target.
  4. Add KeyboardKit.framework to your target as an embedded framework.
Swift Package Manager requires the Swift and Objective-C sources to be separated into modules. The KeyboardKitObjC module is used internally by KeyboardKit and does not need to be imported explicitly by your app.
CocoaPods (legacy)
Up until version 8.2.0, KeyboardKit was available on CocoaPods as Keyboard-Kit. Please use Swift Package Manager or direct installation instead.
Usage
Import the framework:
import KeyboardKit
UIKit
Instead of creating or subclassing a UIKit class directly, use the subclasses from KeyboardKit instead. All KeyboardKit subclasses are named by changing UI to Keyboard. For example replace
classSettingsViewController:UICollectionViewController{...}
with
classSettingsViewController:KeyboardCollectionViewController{...}
Or create KeyboardKit subclasses directly:
lettabBarController=KeyboardTabBarController()
tabBarController.viewControllers =[KeyboardNavigationController(rootViewController:SettingsViewController()),]
In order to receive key commands, an object must be on the responder chain.
You can see more in the KeyboardKitDemo app, and each class includes API documentation in their Swift source file.
SwiftUI
When using the .keyboardShortcut modifier on a Button, access semantically defined KeyboardShortcuts for common actions within the .KeyboardKit namespace:
Button("Save"){
// Save something here in the button action
}.keyboardShortcut(.KeyboardKit.save)
This adds the ability trigger the action of the button by pressing ⌘S.
Learn more
Credits
KeyboardKit is a project from Douglas Hill with the generous help of contributors. Some concepts were originally developed for PSPDFKit and reimplemented in Swift for KeyboardKit. I use KeyboardKit in my reading app.
Contributing
I’d love to have help on this project. For small changes please open a pull request; for larger changes please open an issue first to discuss what you’d like to see.
Tests are not required for new functionality, but fixed regressions should have automated tests. Use KeyboardKitTests for unit tests that don’t need views or a responder chain. Use KeyboardKitDemoUITests for integration tests that can be reproduced in the demo app. This only works on Mac Catalyst currently because iOS does not allow simulating hardware keyboard input. Use KeyboardKitUITests for any test cases between, which is probably most cases.
Licence
MIT license — see License.txt
About
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Resources
Readme
MIT license
Activity
Stars
456 stars
Watchers
5 watching
Forks
13 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - douglashill/KeyboardKit: The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app. · GitHub
Skip to content
BranchesTags
Repository files navigation
KeyboardKit
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Keyboard control is a standard expectation of Mac apps. It’s important on iOS too because a hardware keyboard improves speed and ergonomics, which makes an iPad an even more powerful productivity machine.
KeyboardKit is designed to integrate with the UIKit focus system when available (iPad with iOS 15+, macOS 11+), and it provides similar arrow and tab key navigation on OS versions where the focus system is not available (iPhone, iPad with iOS 13–14, macOS 10.15).
Features
Requirements
Xcode 14.1 or later is required. KeyboardKit supports iOS 13 onwards on iPad and iPhone and macOS 11 onwards with Mac Catalyst (both scaled and optimised). tvOS is not supported. The framework builds for visionOS, but this platform has not been tested.
Installation
Swift Package Manager
Add KeyboardKit to an existing Xcode project as a package dependency:
  1. Navigate to your project settings and then the Package Dependencies tab.
  2. Click the + button.
  3. Enter https://github.com/douglashill/KeyboardKit into the search or package URL field.
Direct
  1. Clone this repository.
  2. Drag KeyboardKit.xcodeproj into your Xcode project.
  3. Add the KeyboardKit target as a dependency of your target.
  4. Add KeyboardKit.framework to your target as an embedded framework.
Swift Package Manager requires the Swift and Objective-C sources to be separated into modules. The KeyboardKitObjC module is used internally by KeyboardKit and does not need to be imported explicitly by your app.
CocoaPods (legacy)
Up until version 8.2.0, KeyboardKit was available on CocoaPods as Keyboard-Kit. Please use Swift Package Manager or direct installation instead.
Usage
Import the framework:
import KeyboardKit
UIKit
Instead of creating or subclassing a UIKit class directly, use the subclasses from KeyboardKit instead. All KeyboardKit subclasses are named by changing UI to Keyboard. For example replace
classSettingsViewController:UICollectionViewController{...}
with
classSettingsViewController:KeyboardCollectionViewController{...}
Or create KeyboardKit subclasses directly:
lettabBarController=KeyboardTabBarController()
tabBarController.viewControllers =[KeyboardNavigationController(rootViewController:SettingsViewController()),]
In order to receive key commands, an object must be on the responder chain.
You can see more in the KeyboardKitDemo app, and each class includes API documentation in their Swift source file.
SwiftUI
When using the .keyboardShortcut modifier on a Button, access semantically defined KeyboardShortcuts for common actions within the .KeyboardKit namespace:
Button("Save"){
// Save something here in the button action
}.keyboardShortcut(.KeyboardKit.save)
This adds the ability trigger the action of the button by pressing ⌘S.
Learn more
Credits
KeyboardKit is a project from Douglas Hill with the generous help of contributors. Some concepts were originally developed for PSPDFKit and reimplemented in Swift for KeyboardKit. I use KeyboardKit in my reading app.
Contributing
I’d love to have help on this project. For small changes please open a pull request; for larger changes please open an issue first to discuss what you’d like to see.
Tests are not required for new functionality, but fixed regressions should have automated tests. Use KeyboardKitTests for unit tests that don’t need views or a responder chain. Use KeyboardKitDemoUITests for integration tests that can be reproduced in the demo app. This only works on Mac Catalyst currently because iOS does not allow simulating hardware keyboard input. Use KeyboardKitUITests for any test cases between, which is probably most cases.
Licence
MIT license — see License.txt
About
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Resources
Readme
MIT license
Activity
Stars
456 stars
Watchers
5 watching
Forks
13 forks
Report repository
Releases
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();
GitHub - douglashill/KeyboardKit: The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app. · GitHub
Skip to content
BranchesTags
Repository files navigation
KeyboardKit
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Keyboard control is a standard expectation of Mac apps. It’s important on iOS too because a hardware keyboard improves speed and ergonomics, which makes an iPad an even more powerful productivity machine.
KeyboardKit is designed to integrate with the UIKit focus system when available (iPad with iOS 15+, macOS 11+), and it provides similar arrow and tab key navigation on OS versions where the focus system is not available (iPhone, iPad with iOS 13–14, macOS 10.15).
Features
Requirements
Xcode 14.1 or later is required. KeyboardKit supports iOS 13 onwards on iPad and iPhone and macOS 11 onwards with Mac Catalyst (both scaled and optimised). tvOS is not supported. The framework builds for visionOS, but this platform has not been tested.
Installation
Swift Package Manager
Add KeyboardKit to an existing Xcode project as a package dependency:
  1. Navigate to your project settings and then the Package Dependencies tab.
  2. Click the + button.
  3. Enter https://github.com/douglashill/KeyboardKit into the search or package URL field.
Direct
  1. Clone this repository.
  2. Drag KeyboardKit.xcodeproj into your Xcode project.
  3. Add the KeyboardKit target as a dependency of your target.
  4. Add KeyboardKit.framework to your target as an embedded framework.
Swift Package Manager requires the Swift and Objective-C sources to be separated into modules. The KeyboardKitObjC module is used internally by KeyboardKit and does not need to be imported explicitly by your app.
CocoaPods (legacy)
Up until version 8.2.0, KeyboardKit was available on CocoaPods as Keyboard-Kit. Please use Swift Package Manager or direct installation instead.
Usage
Import the framework:
import KeyboardKit
UIKit
Instead of creating or subclassing a UIKit class directly, use the subclasses from KeyboardKit instead. All KeyboardKit subclasses are named by changing UI to Keyboard. For example replace
classSettingsViewController:UICollectionViewController{...}
with
classSettingsViewController:KeyboardCollectionViewController{...}
Or create KeyboardKit subclasses directly:
lettabBarController=KeyboardTabBarController()
tabBarController.viewControllers =[KeyboardNavigationController(rootViewController:SettingsViewController()),]
In order to receive key commands, an object must be on the responder chain.
You can see more in the KeyboardKitDemo app, and each class includes API documentation in their Swift source file.
SwiftUI
When using the .keyboardShortcut modifier on a Button, access semantically defined KeyboardShortcuts for common actions within the .KeyboardKit namespace:
Button("Save"){
// Save something here in the button action
}.keyboardShortcut(.KeyboardKit.save)
This adds the ability trigger the action of the button by pressing ⌘S.
Learn more
Credits
KeyboardKit is a project from Douglas Hill with the generous help of contributors. Some concepts were originally developed for PSPDFKit and reimplemented in Swift for KeyboardKit. I use KeyboardKit in my reading app.
Contributing
I’d love to have help on this project. For small changes please open a pull request; for larger changes please open an issue first to discuss what you’d like to see.
Tests are not required for new functionality, but fixed regressions should have automated tests. Use KeyboardKitTests for unit tests that don’t need views or a responder chain. Use KeyboardKitDemoUITests for integration tests that can be reproduced in the demo app. This only works on Mac Catalyst currently because iOS does not allow simulating hardware keyboard input. Use KeyboardKitUITests for any test cases between, which is probably most cases.
Licence
MIT license — see License.txt
About
The easiest way to add comprehensive hardware keyboard control to an iPad, iPhone, or Mac Catalyst app.
Resources
Readme
MIT license
Activity
Stars
456 stars
Watchers
5 watching
Forks
13 forks
Report repository
Releases
Contributors
Languages