Android apps run on Googlebook without any extra work. Google's Googlebook developer page states it in one line: "If you're already building Android apps, they will work on Googlebook." That's the easy part. "Runs" and "runs well enough to earn Play Store badging and featured placement" are two different bars, and Google's own adaptive-development guidance, plus a three-tier quality system, draws a hard line between them.
What is Googlebook, and does my Android app already work on it?
Googlebook is Google's own laptop category. HP, Dell, Lenovo, Acer, and Asus are already building the hardware, per Google's adaptive-development blog post. For a team with an app already on Google Play, that's the whole compatibility story Google tells: existing apps work.
That's the same shape of announcement Android and iOS teams have both seen this year. What to test before iPhone Duo ships covered the equivalent moment on Apple's side: an old layout still launches on new hardware, and the real work is making that layout look intentional rather than stretched, not getting the app to open at all. Googlebook follows the same pattern, just with Google as both the OS vendor and the one writing the adaptive-layout homework.
What Google's adaptive development guidance actually asks for
Running unmodified is the floor, not the target. Google's guidance breaks the actual work into three buckets, layout, input, and multi-window behavior, plus a fourth piece, continuity, that ties a Googlebook session back to whatever phone or tablet a user was on a minute earlier.
Layout: window size classes and Navigation 3 multi-pane scenes
Google's instruction is specific: build layout decisions around window size classes, not physical display dimensions. A screen can be a Googlebook, a folded tablet, or a resized desktop window, and window size class abstracts over which one it actually is. For multi-pane screens, the guidance points to Navigation 3's ListDetailSceneStrategy and SupportingPaneSceneStrategy for side-by-side layouts, alongside Grid and FlexBox layout primitives and experimental MediaQuery and Styles APIs for whatever those two don't cover.
Input: keyboard, trackpad, contextual cursors and shortcuts
A laptop means keyboard and trackpad input as first-class citizens, not an accessibility afterthought. The checklist covers contextual cursors that change for text entry, pane resizing, and tool selection, right-click context menus and hover states, and integration with the Keyboard Shortcuts Helper. None of that ships for free just because the app compiles on Googlebook; it's UI work layered on top of whatever input handling already exists for touch.
Multi-instance and drag-and-drop
The last bucket is window management: multi-instance support so a user can open independent windows of the same app, plus drag-and-drop both between windows and onto an empty part of the desktop workspace. A document editor, a chat app, or anything with a compare-two-things use case is the natural fit here. A single-screen game or a one-shot utility probably isn't.
One more piece sits outside those three buckets. HandoffActivityData is Google's API for carrying context, document position, active tabs, whatever the app cares about, across phone, tablet, and Googlebook, with optional web fallbacks. It comes from the same post covering everything above, worth knowing if you're pulling requirements straight from Google rather than a summary of it.
How Google Play badging and placement actually work
None of the adaptive work above is required to ship. It's required to get noticed. The same post is direct that badging is the reward: "Google Play highlights optimized titles with dedicated badging, enhanced search, and featured spots" on curated store homepages, and an optimized app is prominently surfaced the moment a user sets up a new Googlebook from their Android phone. Qualify, and there's a commercial layer too, the Apps Experience Program, which Google says unlocks "a new program rate card designed to drive business growth."
The bar for that badging lives on a separate page from the announcement. Google's desktop-tier quality guidelines rank apps from Tier 3 "Adaptive ready" up through Tier 2 "Adaptive optimized" to Tier 1 "Adaptive differentiated," which Google describes as the full desktop-class experience. The criteria are concrete. On keyboard support, the app has to be fully navigable from the keyboard and, in Google's words, maintain "keyboard shortcut parity with equivalent web and desktop versions of the app whenever possible." On window management: "App is able to launch multiple instances of itself in separate windows. Use cases include document editing, web browsing, file management apps, and product comparisons in shopping apps." And on cursor behavior: "App displays customized cursors to indicate how and when users can interact with UI elements and content..."
Badging is a Google Play distribution lever, and it's not the only one changing shape this year. Teams already tracking the November 1 extension on Google Play's target API bar know the pattern: Google ties store-level consequences to specific technical criteria and expects developers to read the primary source rather than wait for a recap of it.
How to prepare your Android app for Googlebook
1. Install Android Studio Canary and open the desktop emulator
Get Android Studio's Canary channel running and launch the desktop emulator inside it before touching any layout code. Google names the desktop emulator specifically for testing free-form window resizing, multi-instance behavior, and the new input methods, and Android Studio's preview builds page is the place to check what's actually shipped in a given build before planning a sprint around a feature that's still behind a flag.
2. Audit layouts against window size classes, not device checks
Search the codebase for anything that branches on a specific screen dimension, a device model string, or a hardcoded density bucket, and replace it with window size class checks. This is the same audit iOS teams ran for size classes on iPhone Duo, and it usually surfaces old device-specific code nobody remembers writing.
3. Wire up keyboard, trackpad and cursor support
Add contextual cursors for text entry, resizing, and tool selection, right-click context menus where touch currently only supports long-press, and Keyboard Shortcuts Helper entries for whatever actions already have a toolbar button. This is the section of Google's checklist most touch-first apps have done zero work on.
4. Add multi-instance and drag-and-drop where it fits the app
Not every app needs this. Decide first whether the app has a genuine multi-window use case, comparing two documents, running two chats, referencing one screen while editing another, before building support for launching independent windows and dragging content between them. Forcing it into an app without that use case is wasted engineering time against a tier system that rewards fit over feature count.
5. Benchmark against the desktop-tier quality guidelines before resubmitting
Walk the app against Tier 1's criteria line by line, keyboard shortcut parity, multi-instance launch, customized cursors, before resubmitting for badging review. Google also ships a shortcut for the layout half of this work: the adaptive skill it released alongside that guidance gives your AI agents the necessary context to help refactor mobile layouts into responsive Compose containers when run through Android CLI. It won't clear the input or window-management criteria on its own, but it's a faster starting point than a manual layout rewrite.
Most Android teams don't have spare capacity sitting around for a five-step adaptive-layout project on top of an existing roadmap. If that's the blocker, hiring Android developers to own the Googlebook work specifically is usually faster than splitting it across whoever's free that sprint.
Googlebook isn't the only platform story worth reading from the source instead of a recap this quarter. Android 17's per-app memory limits came out of Google's own blog post too, no third-party interpretation required, and Platform and language release notes: what breaks and what to fix tracks the rest of what's shipping and breaking across platforms right now.
FAQ
Does my Android app need code changes to run on Googlebook?
No. Google's own line on it is that if you're already building Android apps, they'll work on Googlebook. What isn't automatic is Play Store badging, which depends on the adaptive-layout, input, and multi-window work covered above.
What is the Android Studio Canary desktop emulator?
It's the tool Google names for testing Googlebook-specific behavior before a device ships to your desk: free-form window resizing, multi-instance launches, and keyboard and trackpad input, all inside Android Studio's Canary channel rather than a stable release.
How does Google Play badging work for Googlebook-optimized apps?
Apps that meet Google's adaptive quality bar get dedicated badging, enhanced search visibility, and featured placement on curated Googlebook store homepages, and they're surfaced prominently when a user sets up a new Googlebook from their Android phone. Google grades that bar on a three-tier system, from Tier 3 "Adaptive ready" up to Tier 1 "Adaptive differentiated."
What is the "adaptive skill" in Android CLI?
It's a tool Google shipped alongside its adaptive-development guidance that gives your AI agents the necessary context to help refactor mobile layouts into responsive Compose containers. It handles the layout half of the migration; keyboard support, multi-instance, and cursor behavior still need to be built by hand against the criteria in Google's quality guidelines.