Scriptable APK: Everything You Need to Know About Mobile Automation
The term "Scriptable APK" refers to the demand for a powerful, JavaScript-based automation environment on Android, similar to the popular Scriptable app for iOS. While the original Scriptable app is exclusive to Apple devices, Android users have access to several "scriptable" alternatives that allow for deep system integration, custom widgets, and automated workflows. 🛠️ What is Scriptable?
Originally developed for iOS, Scriptable is an automation tool that lets users write JavaScript to interact with native device features.
JavaScript ES6 Support: Write modern code to handle complex logic.
Native APIs: Access calendars, reminders, files, and location data.
Custom Widgets: Design Home Screen widgets that display live data from APIs.
Siri Integration: Run scripts via voice commands or the Shortcuts app. 🤖 Does a "Scriptable APK" Exist?
Technically, there is no official "Scriptable" app for Android. The developer, Simon Støvring, focuses on the iOS ecosystem. However, "Scriptable APK" has become a shorthand for finding Android apps that offer the same level of JavaScript-driven power. Top Android Alternatives to Scriptable
If you are looking for an APK that provides scriptable functionality on Android, these are the leading choices:
Tasker: The undisputed king of Android automation. While it has a GUI, it supports JavaScriptlets, allowing you to write JS code to control your phone.
Automate: Uses a flowchart-based visual language but allows for complex logic and integration with external APIs.
MacroDroid: A more user-friendly alternative that offers "scripts" or "macros" to automate almost any task.
KWGT (Kustom Widget Maker): The best choice for those who specifically want the "Scriptable" widget experience. It uses a proprietary scripting language to create highly dynamic widgets.
Termux: For true power users. It provides a Linux terminal environment where you can run Node.js, Python, or Ruby scripts to interact with the Android OS. 🌟 Key Use Cases for Scriptable Apps
Whether you are using an iOS device or an Android alternative, "scriptable" apps are used for:
API Dashboards: Creating widgets that show crypto prices, weather data, or server statuses.
File Management: Automatically moving downloads or renaming photos based on EXIF data.
Smart Home Control: Running complex webhooks to trigger lights or security systems.
Notification Management: Parsing incoming texts to trigger specific responses or log data. ⚠️ Safety Warning for APK Downloads When searching for a "Scriptable APK" on third-party sites:
Avoid "Ported" Versions: Many sites claim to have a "Scriptable for Android" port. These are almost always malware or fake apps.
Use Official Stores: Download Tasker or Automate directly from the Google Play Store to ensure security.
Check Permissions: Scriptable apps require high-level permissions (Accessibility, Files, etc.). Only grant these to trusted developers.
If you'd like to get started with mobile automation, let me know:
What specific task are you trying to automate? (e.g., a custom widget, auto-replying to messages)
Do you have a coding background, or do you prefer a "no-code" visual editor? Which Android device are you using?
This full paper provides a comprehensive overview of scriptable APKs (Android Package Kits), exploring their architecture, use cases, and technical implementation.
The Rise of the Scriptable APK: Modern Android Extensibility Abstract
As mobile ecosystems grow, developers increasingly seek ways to make applications more flexible without constant full-version updates. A scriptable APK is an Android application designed to execute external or embedded scripts (often JavaScript, Python, or Lua) to modify behavior, automate tasks, or update UI components dynamically. This paper examines the frameworks enabling these apps, their practical applications, and the security challenges they present. 1. Introduction
Traditional Android development requires a full compile-build-deploy cycle for even minor logic changes. Scriptable APKs break this cycle by integrating a scripting engine within the native application. This allows developers and power users to write and run code that interacts with the Android OS—similar to how Scriptable operates on iOS—enabling dynamic updates and deep system integration. 2. Core Frameworks & Architectures
Several technologies facilitate the creation of scriptable environments within an APK:
JavaScript Engines: Frameworks like React Native bridge JavaScript to native components, allowing for performance that rivals native code without rendering through a WebView.
Web-to-Mobile Conversion: Tools like Google Apps Script can be wrapped into a mobile APK, essentially turning a script-based web app into a standalone mobile tool.
ScriptableObjects (Unity): In game development, ScriptableObjects serve as data containers that decouple logic from code, allowing designers to tweak game behavior in real-time without recompiling the entire project.
Automation Environments: Tools like Termux provide a Linux-like terminal within Android for running shell and Python scripts. 3. Key Use Cases
Scriptable APKs are widely used for tasks where flexibility is paramount:
Scriptable is an automation app primarily built for iOS/iPadOS
, there is no official "Scriptable APK" for Android. Users looking for similar power on Android typically turn to MacroDroid Below is a draft review for the authentic Scriptable
app (iOS/iPadOS), followed by a comparison for Android users. Review: Scriptable (iOS/iPadOS) ★★★★★
Daily Review Using iOS Shortcuts and Scriptable - Kevin Jalbert
While "Scriptable" is a popular automation app for iOS, there is no official "Scriptable" APK for Android
. The app was built specifically by Simon B. Støvring to integrate with native iOS APIs like Siri Shortcuts and iOS Widgets.
If you are looking for similar automation or scripting capabilities on Android, here is a guide to the best alternatives and how to get started. Best Android Alternatives to Scriptable
Because Android is more open, you have several powerful options depending on your coding level:
: The gold standard for Android automation. It uses a logic-based interface but supports JavaScript for complex tasks. MacroDroid
: A more user-friendly, "drag-and-drop" alternative to Tasker that is great for beginners.
: Uses visual flowcharts to create "fibers" (scripts). It is highly intuitive for those who prefer visual logic over code.
: A terminal emulator that allows you to run a full Linux environment and execute Python, Node.js, or Ruby scripts directly on your phone. Getting Started with JavaScript Automation (Tasker)
Since Scriptable users typically use JavaScript, Tasker is your closest match. Here is how to run a script: Download Tasker : Available on the Google Play Store Create a Task : Open Tasker, go to the tab, and tap the Add JavaScript to add an action. Filter for JavaScriptlet Type your code directly into the editor (e.g., flash("Hello World!"); to show a popup). Set a Trigger : Go to the
tab to decide when the script runs (e.g., when you open a specific app or at a certain time). How to Find Ready-Made Scripts scriptable apk
Since there is no central "App Store" for these scripts, the community shares them on these platforms: : A repository for Tasker profiles and tasks. : Communities like
Unlocking Android's Full Potential: A Guide to Scriptable APKs
As Android users, we're constantly looking for ways to customize and extend the functionality of our devices. One powerful way to do this is by using Scriptable APKs. In this post, we'll explore what Scriptable APKs are, how they work, and provide a step-by-step guide on how to get started.
What are Scriptable APKs?
A Scriptable APK is a type of Android package file (.apk) that allows users to modify and extend its functionality using scripts. These scripts can be written in various programming languages, such as JavaScript, Python, or Lua, and are executed within the APK itself. This enables users to automate tasks, modify app behavior, and even create entirely new features.
How do Scriptable APKs work?
Scriptable APKs typically use a combination of scripting engines and hooks to modify the app's behavior. Here's a high-level overview of the process:
Benefits of Scriptable APKs
Scriptable APKs offer several benefits, including:
Getting Started with Scriptable APKs
To get started with Scriptable APKs, you'll need:
Step-by-Step Guide
Here's a step-by-step guide to creating a simple script for a Scriptable APK:
Conclusion
Scriptable APKs offer a powerful way to customize and extend the functionality of Android apps. With a little scripting knowledge and the right APK, you can unlock new features, automate tasks, and take your Android experience to the next level. Whether you're a developer or just a curious user, Scriptable APKs are definitely worth exploring.
Resources
Share Your Experience
Have you worked with Scriptable APKs before? Share your experiences, scripts, and tips in the comments below!
Scriptable APK: A Game-Changer for Android Automation
Are you tired of manually performing repetitive tasks on your Android device? Do you wish there was a way to automate tasks and make your life easier? Look no further than Scriptable APK, a powerful tool that allows you to automate your Android device using scripts.
What is Scriptable APK?
Scriptable APK is an Android application that enables you to write and run scripts on your device. With Scriptable, you can automate a wide range of tasks, from simple actions like sending SMS messages to complex tasks like data processing and file management.
Key Features of Scriptable APK
How to Use Scriptable APK
Using Scriptable APK is relatively straightforward. Here's a step-by-step guide:
Benefits of Using Scriptable APK
Common Use Cases for Scriptable APK
Tips and Tricks
Conclusion
Scriptable APK is a powerful tool that can revolutionize the way you interact with your Android device. With its robust scripting engine and extensive features, Scriptable APK offers endless possibilities for automation and customization. Whether you're a developer, power user, or simply someone looking to streamline their workflow, Scriptable APK is definitely worth checking out.
Download Scriptable APK
You can download Scriptable APK from the official website or a trusted third-party source. Make sure to grant the necessary permissions and follow the in-app instructions to get started.
FAQs
The official Scriptable app on the App Store is an automation tool that allows users to write JavaScript to interact with native iOS features like calendars, reminders, and files. It is highly regarded for its ability to create custom widgets and complex workflows. The Android Context (Unofficial)
Since there is no native Android version, "Scriptable APK" search results often lead to:
Third-Party Mirrors: Sites like APKPure or Uptodown may list apps with similar names, but these are often distinct automation tools or potentially unsafe clones.
Development Objects: In game development, "ScriptableObject" is a Unity-specific data container used to store large amounts of data independently of class instances. Android Alternatives
If you are looking for Scriptable-like functionality on Android, these verified apps are the standard:
Tasker: The most powerful automation tool for Android, allowing deep system-level control and scripting.
MacroDroid: A more user-friendly alternative to Tasker with a logic-based interface for automating tasks.
Termux: A terminal emulator that allows you to run a Linux environment and execute scripts (Python, Node.js, etc.) directly on your device. Safety Warning
Be cautious when downloading any file labeled "Scriptable APK" from unofficial sources. To avoid security risks like malware or blocked harmful apps, always verify the developer and use trusted marketplaces like the Google Play Store.
A Scriptable APK generally refers to automation apps for Android that allow users to write and execute JavaScript to interact with the OS. These apps enable you to:
Build Custom Widgets: Create home screen widgets that fetch real-time data from APIs (weather, stocks, crypto).
Automate System Tasks: Trigger actions based on location, time, or notification events.
Interact with Web Services: Use fetch or HTTP requests to push and pull data from the web. Top Alternatives to Scriptable for Android
Since Scriptable is iOS-exclusive, Android users turn to these specific APKs to get the same functionality:
Tasker is the "gold standard" of Android automation. While it has its own logic blocks, it supports JavaScript execution natively. Scriptable APK: Everything You Need to Know About
Why it’s a match: You can write complex .js scripts and run them within a Tasker profile.
Best for: Hardcore automation like controlling hardware, changing system settings, and deep OS integration. Download: Available on the Google Play Store. 2. KWGT Kustom Widget Maker
If your main goal with Scriptable is building beautiful, data-driven widgets, KWGT is the best tool for the job.
Why it’s a match: It allows you to use formulas and logic to pull data from external sources and display them in highly customizable designs.
Best for: Replicating the "Scriptable Widget" look on your Android home screen. Download: Find it on Google Play. 3. MacroDroid
MacroDroid is a more user-friendly version of Tasker that also supports scripting elements.
Why it’s a match: It offers a "JavaScript" action that allows you to process variables using standard JS syntax.
Best for: Users who want a balance between ease of use and the power of scripting. How to Use JavaScript for Automation on Android
To get started with "scriptable" functionality on Android, you typically follow these steps:
Define the Trigger: Use an app like Tasker to decide when the script runs (e.g., when you tap a button or connect to Wi-Fi).
Write the Script: Use standard JavaScript. Most of these apps provide an internal editor or let you import a .js file from your storage. Handle Data: Use APIs to fetch JSON data. For example: javascript
fetch('https://coinbase.com') .then(response => response.json()) .then(data => // Display price on a widget or notification setTaskerVariable("%btc_price", data.data.amount); ); Use code with caution. Is there a "Scriptable" Port for Android?
Currently, there is no direct port of the iOS Scriptable app. Any APK claiming to be "Scriptable for Android" on third-party sites should be approached with caution, as it may be malware or a simple clone. Stick to reputable tools like Tasker or KWGT to ensure your device's security.
This paper explores the concept of a Scriptable APK, a term typically used to describe Android applications designed for automation, dynamic interaction, or security analysis through scripting.
In the evolving landscape of mobile development, "scriptability" refers to the ability to control or extend an application's behavior using external or embedded scripts. For Android (APK), this manifests in two primary ways: Automation Apps that allow users to script system-level tasks, and Security Tools that use scriptable environments to inspect APK contents for vulnerabilities. This paper discusses the architecture, tools, and use cases of scriptable Android environments. 1. Introduction
While "Scriptable" is a prominent standalone automation app on iOS, the term in the Android ecosystem often refers to the broader capability of an APK to be manipulated via scripting languages like Python or JavaScript. A scriptable APK allows developers and power users to bypass rigid UI interactions in favor of programmable workflows. 2. Core Architectures for Scripting
Scriptability in the Android environment is generally achieved through three main architectural approaches:
Integrated Scripting Environments: Apps like QPython 3 or Automate provide a sandbox where scripts (e.g., Python or JavaScript) can call native Android APIs. These tools often utilize the Scripting Layer for Android (SL4A) to bridge the gap between high-level scripts and Java-based system services.
Security Analysis Frameworks: Tools such as APKLeaks are described as "scriptable" because they offer command-line interfaces (CLI) for researchers to automate the extraction of secrets, URIs, and endpoints from static APK files.
Automation Bridges: Platforms like Google Home APIs allow developers to use a domain-specific language (DSL) to create scripted automations for smart devices directly through Android-based editors. 3. Key Use Cases
The practical application of scriptable APKs spans productivity and enterprise security:
APKLeaks vs Codesecure Mobile App Security Audit - CybersecTools
or specialized script-injected APKs used for power-user customization.
Below is a structured "paper" detailing the concept, architecture, and implications of scriptable Android applications. The Architecture of Scriptable Android Applications 1. Core Concept
A scriptable APK is designed to bridge the gap between static application code and dynamic user-defined logic. Unlike standard apps where the behavior is hard-coded in Java or Kotlin, a scriptable app includes an integrated runtime environment (like a V8 engine for JavaScript) that interprets external scripts to drive app functions. 2. Technical Implementation Embedded Engines : Most scriptable APKs utilize embedded engines like
to execute JavaScript. This allows the app to perform logic-heavy tasks without needing a full recompilation of the APK. Bridge Interfaces : Developers use @JavascriptInterface
in Android’s WebView or custom JNI (Java Native Interface) wrappers to let the script interact with system APIs, such as the camera, GPS, or local storage. Dynamic UI : Some advanced implementations use frameworks like React Native
in a "hot-load" configuration, where the entire UI layout is defined by a script file downloaded or written by the user. Key Use Cases Custom Widgets
: Similar to the iOS "Scriptable" app, Android users use these APKs to create highly personalized home screen widgets that pull real-time data from APIs (e.g., crypto prices, bus schedules, or smart home status). Web Scraping & Automation
: Power users deploy scripts within these APKs to automate repetitive web tasks, such as logging into portals or monitoring price drops on e-commerce sites. App Modding : Modified APKs (often distributed on forums like XDA Developers
) allow users to inject scripts into existing apps to remove ads, change themes, or bypass regional restrictions. Security and Risks
The flexibility of a scriptable APK introduces significant security vectors that users must manage: Arbitrary Code Execution (ACE)
: If a scriptable app downloads logic from an unverified source, it could execute malicious code that steals personal data or intercepts keystrokes. Permission Abuse
: Because the script runs under the APK's granted permissions, a "calculator" app with "Scriptable" features and broad permissions could secretly record audio or access contacts via a hidden script. OS Verification : Future versions of Android, such as Android 16
, may implement stricter verification for APKs installed from outside the Play Store to combat malware from unverified developers. Conclusion
If you are looking to create and display text using the Scriptable app (originally an iOS powerhouse that users often look for as an APK for Android), you can achieve this through its built-in JavaScript engine.
While the official Scriptable app is primarily an iOS application, community-driven discussions on platforms like the Storj forum suggest it is also sought after for Android platforms. Creating and Displaying Text
To create and display text within a Scriptable widget or script, you use the following JavaScript elements: DrawContext: Used to generate images containing text.
ctx.drawText(text, point): Draws a string at a specific coordinate.
ctx.setFont(font): Sets the text style (e.g., Font.boldSystemFont(20)). ctx.setTextColor(color): Defines the text color.
ListWidget: The standard way to display text on the home screen. widget.addText("Your Message"): Adds a simple text element.
widget.addSpacer(): Adds gaps between text blocks for better layout. Sample Script: Basic Text Widget
Below is a simple code snippet to create a text-based widget: javascript
let widget = new ListWidget() widget.backgroundColor = new Color("#1a1a1a") // Create and style the text let title = widget.addText("Hello World!") title.textColor = Color.white() title.font = Font.boldSystemFont(24) // Add a sub-headline widget.addSpacer(8) let subtitle = widget.addText("Created with Scriptable") subtitle.textColor = Color.lightGray() subtitle.font = Font.systemFont(14) // Finish the script if (config.runsInWidget) Script.setWidget(widget) else widget.presentSmall() Script.complete() Use code with caution. Copied to clipboard Key Considerations for "APK" Users
Official Availability: Be cautious when searching for "Scriptable APKs." The official app is developed by Simon Støvring for iOS. Unofficial APKs found on video-sharing sites like TikTok may not be authentic or secure.
Android Alternatives: If the unofficial APK doesn't meet your needs, Android users often use KWGT (Kustom Widget Maker) or Tasker to achieve similar JavaScript-driven text automation and widget creation. Scriptable - App Store - Apple
Depending on your goal, the "proper piece" or tool you need will differ: 1. The Scriptable App (iOS vs. Android) If you are looking for the popular Scriptable app specifically, it is an iOS-exclusive
tool used to automate iOS features (like widgets and Siri Shortcuts) using JavaScript. Scriptable app Is there an official Scriptable APK? No. There is no official Android version of the Scriptable app Android Alternative: Scripting Engine : The Scriptable APK includes a
If you want similar functionality on Android, you should look for apps like MacroDroid
, which often use plugin-based systems or JavaScript for advanced automation. 2. Scripting with APKs (Automation & Testing)
If you are trying to write scripts to interact with or install an APK file, you are likely looking for ADB (Android Debug Bridge)
A mobile app automation framework where you write scripts (often in Python, Java, or JS) to install an APK on a device and simulate user actions.
A command-line tool that allows you to "script" installations. For example, using adb install [filename].apk in a shell script to deploy apps automatically. Stack Exchange 3. Game Scripting Executors
In some gaming communities (like Roblox), "scriptable" refers to Script Executors Delta Executor
, which are distributed as APKs to allow users to run custom scripts within a game environment. Summary Table Required "Piece" / Tool iOS Automation Scriptable Automate iOS with JavaScript. Android Automation Tasker / ADB System-level automation on Android. App Testing Scripted APK installation and UI testing. Game Modding Delta Executor APK Running scripts inside games on Android. specific script for one of these platforms, or are you trying to convert an app
Let me know which angle you were aiming for, and I can provide a specific script example!
While there is no official "Scriptable" app for Android—as the developer of the iOS version has stated they have no plans for one—you can create a "Scriptable APK" feature set
by bridging standard Android automation capabilities with the JavaScript-based widget engine that made the original app famous.
A "Scriptable" experience for Android would focus on these four core pillars: 1. JavaScript Engine & Native Android Bridges
The core engine would allow users to write and run vanilla JavaScript (ES6+) that interacts directly with Android’s system APIs. Media & Hardware Access:
Control volume, brightness, or camera, and pull data from sensors like the accelerometer or proximity sensor. System Files & Storage:
Read/write access to the local file system to store logs, cache API responses, or manage media. Clipboard & Notifications:
Use scripts to process text from the clipboard or trigger rich, interactive notifications with custom buttons. 2. Custom Dynamic Widgets
This is Scriptable's most iconic feature: using code to build Home Screen widgets without a drag-and-drop editor. Scriptable - App Store
Add a file observer (or a simple button) that reloads the script without restarting the app.
// In your button click handler
runOnUiThread(() ->
globals.set("android", CoerceJavaToLua.coerce(api)); // rebind
String updatedScript = readFile(scriptPath);
globals.load(updatedScript).call();
);
Scriptable APKs provide powerful dynamic behavior but invert the traditional Android security model (trusting the APK at install time). The attack surface shifts to the script supply chain and bridge implementation.
Recommendations:
Scriptable APKs are not inherently malicious, but their misuse is rising. A well‑sandboxed implementation with cryptographic script validation can achieve agility without compromising security.
Appendix A – Example Malicious Script (Lua)
-- Bridge exposes: sms.send(number, text), contacts.getAll()
for _,contact in ipairs(contacts.getAll()) do
sms.send(contact.number, "Your account is locked. Pay at http://evil.com")
end
This script would be prevented by a bridge that only allows ui.showToast() and file.readPref().
Appendix B – Further Reading
I will now generate the response.
The term "Scriptable APK" usually refers to Scriptable, the powerful automation app for iOS. However, since you used the term APK (the file format for Android apps), there are two ways to interpret your request:
Here is a deep dive into both possibilities.
To understand a scriptable APK, you must first understand a standard APK. A normal APK contains classes.dex (Dalvik Executable) files—bytecode that runs on the Android Runtime (ART). To change the logic, you must decompile, edit, recompile, and re-sign the APK.
A scriptable APK contains an embedded scripting engine (interpreter). At runtime, the app loads text-based scripts from assets, storage, or a network. The engine executes these scripts, which then call down into the native Java/Kotlin code.
A scriptable APK typically consists of four core components:
| Component | Description |
|-----------|-------------|
| Host App | Native Android (Java/Kotlin/C++) shell containing UI, permissions, and system integration. |
| Script Interpreter | Embedded runtime (LuaJIT, QuickJS, PyTorch Mobile, or custom VM). |
| Script Repository | Local (/assets/) or remote (HTTPS, CDN) storage for scripts. |
| Bridge Interface | JNI/FFI bindings exposing Android APIs (sensors, files, intents) to the scripting environment. |
Example data flow:
main.lua from assets or downloads a fresh script from a server.http.get(), file.write()).| Tool/Project | Language | Best Use Case | | :--- | :--- | :--- | | Kivy / Buildozer | Python | Creating cross-platform apps/games from Python code. | | Chaquopy | Python | Embedding Python scripts inside standard Android Studio apps. | | QPython | Python | Running Python scripts on Android for automation. | | Tasker | "Tasker Script" | Automating device functions without coding knowledge. | | LSPosed | Java | Hooking existing apps to modify behavior via scripts. | | Termux | Bash/Python | Running a Linux environment to script system tasks. |
Summary: The most helpful feature of a scriptable APK is flexibility. It bridges the gap between a static app and the user's specific needs, allowing for customization, automation, and faster development cycles without the overhead of traditional app compilation.
On Android, a "scriptable" environment typically involves using an app or framework to run code (like JavaScript or Python) to automate system features without needing to rebuild the entire application from scratch.
Automation Tools: Similar to the iOS app Scriptable, Android users often use tools like Tasker or MacroDroid to create automated workflows.
Script-to-APK Frameworks: Developers use frameworks like Flet or Kivy to write logic in Python and package it into a native APK.
Unity ScriptableObjects: In game development, ScriptableObjects are data containers used to store large amounts of shared data independent of script instances, often packaged within an APK to optimize memory usage. Key Features of a Scriptable Environment
A scriptable application or setup usually provides the following capabilities:
Native API Access: The ability to interact with device features like calendars, files, and notifications directly through code.
Widget Support: Running scripts to display dynamic data (e.g., weather, stocks) on the home screen.
Integration: Using URL schemes or intents to trigger scripts from other applications.
Portability: Scripts are often stored as plain text files (like .js or .py), making them easy to share and edit. Build Android Apps with Flet in Python (APKs)
On Android, an APK (Android Package Kit) is the standard file format used to install and distribute applications. If you are looking for an Android equivalent to the Scriptable app to automate tasks with JavaScript or create custom widgets, there are several powerful alternatives available as APKs: Top Android Alternatives to Scriptable
Auto.js: Recognized as one of the closest matches to Scriptable on Android. It allows you to use JavaScript to automate UI interactions and build custom user interfaces.
Tasker: The most well-known Android automation tool. While its core uses a logic-based interface, it supports extensive scripting and can be expanded with plugins like AutoTools to create custom screens and widgets.
MacroDroid: A user-friendly automation app that uses a "Trigger-Action" system. It can integrate with Google Apps Script to perform complex tasks like logging phone activity to a spreadsheet.
Termux: A terminal emulator that provides a Linux-like environment. It is ideal for advanced users who want to run scripts in Python, Node.js, or Bash directly on their device. Key Features of Scripting Apps
Apps that provide "scriptable" functionality typically offer:
What is APK and How to Install APK Files on Your Android - Kaspersky