Drive The Epic Cars (ALPHA) Mac OS

1. Drive The Epic Cars (alpha) Mac Os Catalina
2. Drive The Epic Cars (alpha) Mac Os Update
3. Drive The Epic Cars (alpha) Mac Os Download

Memory usage

Explore the world of Mac. Check out MacBook Pro, MacBook Air, iMac, Mac mini, and more. Visit the Apple site to learn, buy, and get support. Recommended for media such as Documentaries, Sci-Fi Movies, Epic Movies, Medieval Mood, Drama, Spaghetti Western and Inspirational Videos. Phrases - Vocals - Bonus Requirements: Kontakt 6.22 (FULL), not compatible with Kontakt Player. Compatible with MAC OS 10.13 (or higher) and Windows 7/10 8 GB System Ram. The driver in madalin stunt cars 3 is smarter than ever. The epic 3d racing game returns with brand new levels and cars for you to race. Enjoy playing madalin stunt cars 3 games online for free! On madalin games you will find the latest version of stunt cars 2, browser version (webgl) and downloadable version for windows, mac os x, linux.

If you're reading this article for tips on how to improve your Mac OS X experience, now's the time to pay attention. Aside from purchasing a new Mac, the most important thing you can do to make Mac OS X more bearable is to buy more RAM. Go ahead, don't be shy. 512MB sticks are going for as little as $50 if you look hard enough.

Frequent readers may recall that both the G3/400 and the dual G4/450 had only 256MB RAM at the time of the 10.0 review. After using 10.0.x for a few weeks on the G4, I got sick of hearing my disk grinding constantly and upgraded to 512MB. The silence that followed was truly golden. It was a bigger improvement than any of the 10.0.x upgrades, by far.

Drive The Epic Cars (alpha) Mac Os Catalina

(Although the G3/400 primarily runs Mac OS 9, I upgraded it to 384MB because, well, RAM was too damn cheap not to, I guess.)

After a few weeks at 512MB, the G4 started to get a little grind-happy again. I shuffled some RAM between machines to boost the G4 again to its current total of 768MB, and noticed a nearly linear boost in 'smoothness' in daily use.

What's going on here? Where is all this memory going? Is Mac OS X a black hole for RAM? In a word, yes. But that's actually a good thing..sort of. I talked about Mac OS X's virtual memory system as it relates to the user experience and the infamous 'minimum required system' in the 10.0 article. I'd like to take a short break from the 'review' portion of this article and go into more detail about Mac OS X's memory system (as requested by numerous readers). Feel free to skip ahead to the summary if you're only interested in the RAM usage performance of 10.1 relative to 10.0.x.

(Note: A lot of the information presented below is heavily simplified in an effort to reach as broad an audience as possible. If you're interested in the gory details, picking up a good book on the topic is your best bet.)

Virtual Memory Basics

Mac OS X manages memory very differently than classic Mac OS. Your life mac os. The first key to understanding memory usage in Mac OS X is to be understand how a modern virtual memory system works.

In a virtual memory management system, there is a distinction between real, physical memory and 'virtual' memory. An application's virtual memory size is the amount of memory the application thinks it has allocated, but only a (possibly very small) portion of that memory may actually be stored in the real, physical RAM chips sticking out of your computer's motherboard at any given time. The rest exists on disk in some form, usually in one or more 'swap files.'

The operating system decides what portion of which processes exist in physical memory at any given time. This decision process is complex, and varies from OS to OS, but it usually uses recent usage statistics in its decision making process. A process that has not accessed a particular piece of (real, physical) memory for a long time may find that memory written out to disk so that another more active process can use that piece of physical memory. When a process has a large portion of its memory removed from physical RAM and placed on the disk, it is said to be 'swapped out.'

If a process needs a previously swapped-out piece of memory again, it will be transferred from disk back into physical memory—possibly in a different location than its earlier home in physical memory. When a previously swapped-out application becomes active again and causes a large portion of its memory to move from disk back to physical memory, it is said to be 'swapped in.'

To simplify memory management, the operating system deals with memory in uniform units of a minimum size (usually 4K) called 'pages.' Swapping out a page is also called a 'pageout', and swapping in a page is called a 'pagein.' The policy used by the operating system to control memory management is often called the 'paging algorithm.'

Memory pages may store almost anything: code, data, even pieces of files. In fact, one of the useful features of virtual memory is that entire files may be 'memory mapped': a file on disk may be accessed as if it's a series of memory pages that have been swapped out to disk.

Further optimization is possible by allowing processes that need access to the same information (code, data, files) to share memory pages. Only when one of the processes sharing a particular memory page chooses to modify that page is a private copy created. This behavior is aptly named 'copy-on-write', and it allows many processes to efficiently share memory, with only the 'differences' allocated separately.

Not all memory may be swapped out. Some pages are 'wired down', meaning they may never leave physical memory during their lifetime. The memory pages that contain the operating system code that control the paging algorithm can never be swapped out, for instance (think about it). In fact, much of the operating system kernel is usually wired down.

Each active process needs some minimum portion of its memory pages to exist in physical memory in order to function efficiently. This portion is called the 'working set.' When the working set of all the active processes cannot fit in physical memory, the operating system must constantly shuttle pages to and from physical memory and the disk in a sort of game of musical chairs gone terribly wrong. A computer in this state is said to be 'thrashing.' The only cure is to either decrease the number active processes or buy more RAM.

The Buffer Cache

The second most important factor in Mac OS X's memory usage behavior is the buffer cache. The buffer cache is meant to speed up access to files on disk. Every time a piece of data is read from the disk, it may (optionally) be stored in memory. If that same piece of data is needed again in the near future, it may still be available in (physical) memory, saving a trip to the disk. Mac OS X implements a 'unified buffer cache', meaning that the buffer cache and the virtual memory system are combined. A page is a page is a page in Mac OS X.

The buffer cache affects RAM usage in ways that a Mac user may not expect. Heavy file i/o can use a lot of physical memory very quickly, potentially thinning out the physical memory presence of running applications. Poorly written applications may exacerbate this problem by using cached file i/o when it is not necessary, or even useful. An application that reads and parses a large file a single time during start-up should probably not use caching i/o, since it is not likely that the application will need those memory pages again some time in the near future before they're evicted from physical memory by another active process.

The Window Server

The final major player in the Mac OS X memory ballet is, perhaps surprisingly, the window server. The window server orchestrates access to the screen, including both low-level drawing and higher-level concepts like the movement and layering of windows.

As discussed in earlier articles, the Quartz display layer (of which the window server is an important part) models the screen as a layered compositing engine much like the layers in a graphics application like Photoshop. Each pixel has a red, green, and blue components, plus a so-called 'alpha channel' which determines its transparency, from totally opaque to totally invisible. The appearance of each pixel on the screen is determined by the composite of all the applications that have a pixel in that position. The window server calculates the composite of those pixels based on the layering and visibility of the participating pixels.

This provides the infrastructure for many of the 'pretty' effects in Mac OS X: the transparent drop-shadows on the windows, the translucent menus and title bars, etc. Circled. mac os. Each individual application only needs to worry about its own pixels, without regard for anything in front of or behind it. The window server then composites those pixels and draws the result to the screen. This makes application development simpler, leaving the 'hard work' of creating those nice on-screen effects to the operating system rather than each application.

Things get tricky again something on the screen has to move or change color (or transparency). The window server must re-composite every pixel changed by an application before the change can become visible to the user. And the compositing calculation needs not only the value of the changed pixel, but also the values of all other pixels that contribute to that position.

Think about the calculations necessary to do something as simply as move a window in Mac OS X. Every pixel of that window must be re-composited with every pixel of every application in each location for each new position of the window. Imagine a 500x300 pixel window (about 24 rows of 80 column text) moved 100 pixels to the right, with 5 other application windows behind it. That's about 15 million compositing calculations, each with 30 operands (red, green, blue, and alpha values for each contributing pixel from each application), all for moving a small window a few inches.

But wait, there's more. When something changes on the screen (a window moves, appears, or disappears), pixels belonging to other applications are revealed. Those pixels must, of course, be composited before they can be displayed, and those compositing calculations need all the pixel values for each application that has a pixel in the newly revealed area. Adding the compositing calculations associated with the newly revealed screen area in the moving window example above (and accounting for the transparent drop-shadow on the window) brings the grand total to almost 17 million 20-30 operand calculations!

Of course, this is a worst-case scenario that would only happen in a very naive implementation. Many optimization are possible. Solid pixels can abbreviate the number and difficulty of the compositing calculations tremendously, especially if the front-most pixel is solid.

But there's no getting around the fact that the window server still needs access to all the pixels of all the windows on the screen at all times, since it never knows when one of them will be required in a compositing calculation. Furthermore, this access needs to be very fast, since no one wants to wait while the OS reads pixels from a slow medium like disk.

Mac OS X provides the window server with fast access to pixels by making all windows 'buffered.' All the pixels of a buffered window are stored in in memory. When one of those pixels is needed in a compositing calculation, the window server simply reads the memory location corresponding to that pixel. It does not have to 'ask' the application for the pixel. In fact, an application may be entirely frozen and unresponsive, but its window can still be moved around, hidden, and revealed without any participation from the application. When an application wants to change its window, the changes are all sent through the window server, which updates the window's buffer to reflect the changes.

This is a big change from classic Mac OS, where each application drew directly to the screen, and any newly revealed portion of a window had to be re-drawn by the application that owned that window. Window buffering and compositing had to be implemented explicitly by each application that wanted it, and it was totally independent of any other running applications.

From a development perspective, buffered windows make applications easier to code. Drawing only has to be done once, after which portions of the window may be hidden and revealed without triggering any custom redraw code in the application. From a user's perspective, window buffering allows newly revealed windows to 'just be there,' with no visible redraw. Buffering also provides smooth, flicker-free window movement. Mac OS X even goes so far as to synchronize screen drawing with the sweep of the electron beam on CRTs to avoid flicker and 'tearing.'

Quartz's buffering is generally a good thing. It improves the visual quality of on-screen elements and it makes application development easier. But what does all of this have to do with memory usage?

We've already seen the potentially tremendous number of calculations required to composite items on the screen. These calculations are all done by the CPU in Mac OS X, and are not off-loaded to a video card's GPU. But surprisingly, this is not as large a CPU hit as you might expect, thanks to both the common case of totally opaque pixels and the speed of today's CPUs (yes, even on Macs). A few million calculations every once in a while may cause a some instantaneous load on the CPU, but it is not really a factor in the long term. That said, it would be great to have the video card do these calculations rather than the CPU—something I'm sure Apple is working on. In pathological cases (e.g. the famous shaking transparent terminal window) the CPU load can briefly become significant.

But it's the memory usage that's the real killer. Classic Mac OS applications only need to retain the essential information about each window: its size, features, and contents. Mac OS X applications have to retain the same information, of course, but remember that the window server also has to retain a complete memory image of every pixel in the window! Repeat this for every single window on the screen, and it adds up very quickly.

Classic Mac OS requires only a few kilobytes to store the basic structures that define a simple, empty window. In Mac OS X, the total memory required for even a completely empty window is proportional to its size, regardless of the nature of its contents (if any).

In my daily work as a web programmer, this difference is very apparent. The nature of the work requires many windows to be open at once: text editors, web browsers, terminals, etc. In classic Mac OS, each text editor window, for example, would require only a small amount of memory for the window itself, plus whatever backing store the editor keeps for the (ASCII) text in each window. In Mac OS X, each simple text editor window becomes a giant 32-bit image (in addition to the other information, of course). Multiply this phenomenon across all the other applications, each with many windows of their own, and you quickly run into trouble.

Take a look at this window list from a typical work day on my G4. The total memory used by window buffers alone is an astounding 120MB! And remember, this is before even accounting for things like, say, the memory required by the actual applications and the core OS itself!

(The possibility of decreasing the window server's memory usage—and, more importantly, decreasing memory bandwidth usage—by compressing inactive window buffers is intriguing, but this feature is not officially supported in 10.1.) Stake your acclaim mac os.

The window server uses the same virtual memory system as every other part of OS X, of course. That means that the memory that makes up each window buffer is eligible to be paged out just like any other piece of memory. This is where the real performance hit comes in. Attempting to manipulate a window that has had some or all of its window buffer pages swapped out is a painful, stuttering, disk grinding experience as the virtual memory system rapidly tries to bring those pages back into physical memory from disk (evicting other resident pages while doing so, of course).

I encounter this phenomenon on a grand scale every time I return to work on Monday, after a weekend spent connected to the G4 via the command line running non-GUI applications from the terminal. On those Monday mornings, almost every window buffer is likely to have been swapped out during the weekend. The disk grinding session that ensues when all the windows are paged back in as I start to use them again is quite spectacular.

And remember, this is a system with 768MB of RAM. But the OS doesn't care. My command line work over the weekend required significant memory (compiling, running web servers, etc.), and the OS provided it. None of the GUI applications were active over the weekend, so their pages were swapped out to disk to make way for the memory needs of the command line activity. This is to be construed as a feature.

So, buffered windows: friend or foe? In the end, they are a friend. The OS X window server provides a higher level of abstraction to applications. With more abstraction comes more resource usage. But 'increased abstraction' is essentially the definition of progress in the computer industry (otherwise we'd all still be programming in machine language). But like much of the rest of OS X, pervasive window buffering is slightly ahead of current state of hardware. Long-term, this is also a good thing, in my opinion. It's easier to wait for hardware to catch up to your ambitious (but clean) software architecture than it is to try to revamp your operating system in response to advances in hardware (just ask Apple ;-)

Swap File Optimizations

Since it is possible to use up almost any amount of physical RAM in OS X (I fill 768MB very quickly), further performance gains are still possible by moving the swap file(s) to a separate disk. No matter how much RAM you have, you will almost certainly hit the swap file eventually. The disk heads on the drive containing the OS and applications will already be scurrying around as they read and write application and OS code and data files. Making the swap file another stop on their frantic journey just adds yet another voice to the cacophony of disk grinding. Swap file access is especially painful since is usually interleaved with other disk operations: read a piece of application code from disk into memory, write an old memory page out to the swap file, read a piece of a data file into the buffer cache, write an old memory page out to the swap file, read a piece of application code from disk into memory..etc. etc. (Can you hear the grinding? :-)

Putting the swap file on a disk mechanism of its own allows the heads on that disk drive to benefit from better locality of reference (i.e. they don't have to move around as much), and frees the application and OS drive to concentrate on its tasks. There is no Apple-sanctioned way to move the swap file to another drive, and certainly no GUI for it. But brave users can follow the directions available on the web. Just be sure to make a total backup first, because you can potentially hose your entire system if you're not careful.

I only have one disk at work, but at home I've moved my swap file from the 12GB 5,400 RPM drive that houses OS X and all its applications to my 45GB 7,200 RPM Mac OS 9 drive. The reduction in disk grinding has been substantial.

Simply moving the swap file to dedicated partition on the same disk is of much smaller benefit (if any). The disk heads still need to make many trips to and from the swap partition and the rest of the disk. And since Mac OS X uses individual swap files (rather than a dedicated swap file system), a separate swap partition is only likely to make a significant difference if the previous swap files were heavily fragmented on disk. (Note: I'm talking about 'external' fragmentation, where pieces of each swap file are spread all over the disk. The swap files themselves are always heavily 'internally' fragmented, meaning difference pieces of memory are spread sparsely within each swap file.)

To use a keyboard shortcut, press and hold one or more modifier keys and then press the last key of the shortcut. For example, to use Command-C (copy), press and hold the Command key, then the C key, then release both keys. Mac menus and keyboards often use symbols for certain keys, including modifier keys:

On keyboards made for Windows PCs, use the Alt key instead of Option, and the Windows logo key instead of Command.

Some keys on some Apple keyboards have special symbols and functions, such as for display brightness , keyboard brightness , Mission Control, and more. If these functions aren't available on your keyboard, you might be able to reproduce some of them by creating your own keyboard shortcuts. To use these keys as F1, F2, F3, or other standard function keys, combine them with the Fn key.

Drive The Epic Cars (alpha) Mac Os Update

Cut, copy, paste, and other common shortcuts

• Command-X: Cut the selected item and copy it to the Clipboard.
• Command-C: Copy the selected item to the Clipboard. This also works for files in the Finder.
• Command-V: Paste the contents of the Clipboard into the current document or app. This also works for files in the Finder.
• Command-Z: Undo the previous command. You can then press Shift-Command-Z to Redo, reversing the undo command. In some apps, you can undo and redo multiple commands.
• Command-A: Select All items.
• Command-F: Find items in a document or open a Find window.
• Command-G: Find Again: Find the next occurrence of the item previously found. To find the previous occurrence, press Shift-Command-G.
• Command-H: Hide the windows of the front app. To view the front app but hide all other apps, press Option-Command-H.
• Command-M: Minimize the front window to the Dock. To minimize all windows of the front app, press Option-Command-M.
• Command-O: Open the selected item, or open a dialog to select a file to open.
• Command-P: Print the current document.
• Command-S: Save the current document.
• Command-T: Open a new tab.
• Command-W: Close the front window. To close all windows of the app, press Option-Command-W.
• Option-Command-Esc: Force quit an app.
• Command–Space bar: Show or hide the Spotlight search field. To perform a Spotlight search from a Finder window, press Command–Option–Space bar. (If you use multiple input sources to type in different languages, these shortcuts change input sources instead of showing Spotlight. Learn how to change a conflicting keyboard shortcut.)
• Control–Command–Space bar: Show the Character Viewer, from which you can choose emoji and other symbols.
• Control-Command-F: Use the app in full screen, if supported by the app.
• Space bar: Use Quick Look to preview the selected item.
• Command-Tab: Switch to the next most recently used app among your open apps.
• Shift-Command-5: In macOS Mojave or later, take a screenshot or make a screen recording. Or use Shift-Command-3 or Shift-Command-4 for screenshots. Learn more about screenshots.
• Shift-Command-N: Create a new folder in the Finder.
• Command-Comma (,): Open preferences for the front app.

Sleep, log out, and shut down shortcuts

Drive The Epic Cars (alpha) Mac Os Download

You might need to press and hold some of these shortcuts for slightly longer than other shortcuts. This helps you to avoid using them unintentionally.

• Power button: Press to turn on your Mac or wake it from sleep. Press and hold for 1.5 seconds to put your Mac to sleep.* Continue holding to force your Mac to turn off.
• Option–Command–Power button* or Option–Command–Media Eject : Put your Mac to sleep.
• Control–Shift–Power button* or Control–Shift–Media Eject : Put your displays to sleep.
• Control–Power button* or Control–Media Eject : Display a dialog asking whether you want to restart, sleep, or shut down.
• Control–Command–Power button:* Force your Mac to restart, without prompting to save any open and unsaved documents.
• Control–Command–Media Eject : Quit all apps, then restart your Mac. If any open documents have unsaved changes, you will be asked whether you want to save them.
• Control–Option–Command–Power button* or Control–Option–Command–Media Eject : Quit all apps, then shut down your Mac. If any open documents have unsaved changes, you will be asked whether you want to save them.
• Control-Command-Q: Immediately lock your screen.
• Shift-Command-Q: Log out of your macOS user account. You will be asked to confirm. To log out immediately without confirming, press Option-Shift-Command-Q.

* Does not apply to the Touch ID sensor.

Finder and system shortcuts

• Command-D: Duplicate the selected files.
• Command-E: Eject the selected disk or volume.
• Command-F: Start a Spotlight search in the Finder window.
• Command-I: Show the Get Info window for a selected file.
• Command-R: (1) When an alias is selected in the Finder: show the original file for the selected alias. (2) In some apps, such as Calendar or Safari, refresh or reload the page. (3) In Software Update preferences, check for software updates again.
• Shift-Command-C: Open the Computer window.
• Shift-Command-D: Open the desktop folder.
• Shift-Command-F: Open the Recents window, showing all of the files you viewed or changed recently.
• Shift-Command-G: Open a Go to Folder window.
• Shift-Command-H: Open the Home folder of the current macOS user account.
• Shift-Command-I: Open iCloud Drive.
• Shift-Command-K: Open the Network window.
• Option-Command-L: Open the Downloads folder.
• Shift-Command-N: Create a new folder.
• Shift-Command-O: Open the Documents folder.
• Shift-Command-P: Show or hide the Preview pane in Finder windows.
• Shift-Command-R: Open the AirDrop window.
• Shift-Command-T: Show or hide the tab bar in Finder windows.
• Control-Shift-Command-T: Add selected Finder item to the Dock (OS X Mavericks or later)
• Shift-Command-U: Open the Utilities folder.
• Option-Command-D: Show or hide the Dock.
• Control-Command-T: Add the selected item to the sidebar (OS X Mavericks or later).
• Option-Command-P: Hide or show the path bar in Finder windows.
• Option-Command-S: Hide or show the Sidebar in Finder windows.
• Command–Slash (/): Hide or show the status bar in Finder windows.
• Command-J: Show View Options.
• Command-K: Open the Connect to Server window.
• Control-Command-A: Make an alias of the selected item.
• Command-N: Open a new Finder window.
• Option-Command-N: Create a new Smart Folder.
• Command-T: Show or hide the tab bar when a single tab is open in the current Finder window.
• Option-Command-T: Show or hide the toolbar when a single tab is open in the current Finder window.
• Option-Command-V: Move the files in the Clipboard from their original location to the current location.
• Command-Y: Use Quick Look to preview the selected files.
• Option-Command-Y: View a Quick Look slideshow of the selected files.
• Command-1: View the items in the Finder window as icons.
• Command-2: View the items in a Finder window as a list.
• Command-3: View the items in a Finder window in columns.
• Command-4: View the items in a Finder window in a gallery.
• Command–Left Bracket ([): Go to the previous folder.
• Command–Right Bracket (]): Go to the next folder.
• Command–Up Arrow: Open the folder that contains the current folder.
• Command–Control–Up Arrow: Open the folder that contains the current folder in a new window.
• Command–Down Arrow: Open the selected item.
• Right Arrow: Open the selected folder. This works only when in list view.
• Left Arrow: Close the selected folder. This works only when in list view.
• Command-Delete: Move the selected item to the Trash.
• Shift-Command-Delete: Empty the Trash.
• Option-Shift-Command-Delete: Empty the Trash without confirmation dialog.
• Command–Brightness Down: Turn video mirroring on or off when your Mac is connected to more than one display.
• Option–Brightness Up: Open Displays preferences. This works with either Brightness key.
• Control–Brightness Up or Control–Brightness Down: Change the brightness of your external display, if supported by your display.
• Option–Shift–Brightness Up or Option–Shift–Brightness Down: Adjust the display brightness in smaller steps. Add the Control key to this shortcut to make the adjustment on your external display, if supported by your display.
• Option–Mission Control: Open Mission Control preferences.
• Command–Mission Control: Show the desktop.
• Control–Down Arrow: Show all windows of the front app.
• Option–Volume Up: Open Sound preferences. This works with any of the volume keys.
• Option–Shift–Volume Up or Option–Shift–Volume Down: Adjust the sound volume in smaller steps.
• Option–Keyboard Brightness Up: Open Keyboard preferences. This works with either Keyboard Brightness key.
• Option–Shift–Keyboard Brightness Up or Option–Shift–Keyboard Brightness Down: Adjust the keyboard brightness in smaller steps.
• Option key while double-clicking: Open the item in a separate window, then close the original window.
• Command key while double-clicking: Open a folder in a separate tab or window.
• Command key while dragging to another volume: Move the dragged item to the other volume, instead of copying it.
• Option key while dragging: Copy the dragged item. The pointer changes while you drag the item.
• Option-Command while dragging: Make an alias of the dragged item. The pointer changes while you drag the item.
• Option-click a disclosure triangle: Open all folders within the selected folder. This works only when in list view.
• Command-click a window title: See the folders that contain the current folder.
• Learn how to use Command or Shift to select multiple items in the Finder.
• Click the Go menu in the Finder menu bar to see shortcuts for opening many commonly used folders, such as Applications, Documents, Downloads, Utilities, and iCloud Drive.

Document shortcuts

The behavior of these shortcuts may vary with the app you're using.

• Command-B: Boldface the selected text, or turn boldfacing on or off.
• Command-I: Italicize the selected text, or turn italics on or off.
• Command-K: Add a web link.
• Command-U: Underline the selected text, or turn underlining on or off.
• Command-T: Show or hide the Fonts window.
• Command-D: Select the Desktop folder from within an Open dialog or Save dialog.
• Control-Command-D: Show or hide the definition of the selected word.
• Shift-Command-Colon (:): Display the Spelling and Grammar window.
• Command-Semicolon (;): Find misspelled words in the document.
• Option-Delete: Delete the word to the left of the insertion point.
• Control-H: Delete the character to the left of the insertion point. Or use Delete.
• Control-D: Delete the character to the right of the insertion point. Or use Fn-Delete.
• Fn-Delete: Forward delete on keyboards that don't have a Forward Delete key. Or use Control-D.
• Control-K: Delete the text between the insertion point and the end of the line or paragraph.
• Fn–Up Arrow: Page Up: Scroll up one page.
• Fn–Down Arrow: Page Down: Scroll down one page.
• Fn–Left Arrow: Home: Scroll to the beginning of a document.
• Fn–Right Arrow: End: Scroll to the end of a document.
• Command–Up Arrow: Move the insertion point to the beginning of the document.
• Command–Down Arrow: Move the insertion point to the end of the document.
• Command–Left Arrow: Move the insertion point to the beginning of the current line.
• Command–Right Arrow: Move the insertion point to the end of the current line.
• Option–Left Arrow: Move the insertion point to the beginning of the previous word.
• Option–Right Arrow: Move the insertion point to the end of the next word.
• Shift–Command–Up Arrow: Select the text between the insertion point and the beginning of the document.
• Shift–Command–Down Arrow: Select the text between the insertion point and the end of the document.
• Shift–Command–Left Arrow: Select the text between the insertion point and the beginning of the current line.
• Shift–Command–Right Arrow: Select the text between the insertion point and the end of the current line.
• Shift–Up Arrow: Extend text selection to the nearest character at the same horizontal location on the line above.
• Shift–Down Arrow: Extend text selection to the nearest character at the same horizontal location on the line below.
• Shift–Left Arrow: Extend text selection one character to the left.
• Shift–Right Arrow: Extend text selection one character to the right.
• Option–Shift–Up Arrow: Extend text selection to the beginning of the current paragraph, then to the beginning of the following paragraph if pressed again.
• Option–Shift–Down Arrow: Extend text selection to the end of the current paragraph, then to the end of the following paragraph if pressed again.
• Option–Shift–Left Arrow: Extend text selection to the beginning of the current word, then to the beginning of the following word if pressed again.
• Option–Shift–Right Arrow: Extend text selection to the end of the current word, then to the end of the following word if pressed again.
• Control-A: Move to the beginning of the line or paragraph.
• Control-E: Move to the end of a line or paragraph.
• Control-F: Move one character forward.
• Control-B: Move one character backward.
• Control-L: Center the cursor or selection in the visible area.
• Control-P: Move up one line.
• Control-N: Move down one line.
• Control-O: Insert a new line after the insertion point.
• Control-T: Swap the character behind the insertion point with the character in front of the insertion point.
• Command–Left Curly Bracket ({): Left align.
• Command–Right Curly Bracket (}): Right align.
• Shift–Command–Vertical bar (|): Center align.
• Option-Command-F: Go to the search field.
• Option-Command-T: Show or hide a toolbar in the app.
• Option-Command-C: Copy Style: Copy the formatting settings of the selected item to the Clipboard.
• Option-Command-V: Paste Style: Apply the copied style to the selected item.
• Option-Shift-Command-V: Paste and Match Style: Apply the style of the surrounding content to the item pasted within that content.
• Option-Command-I: Show or hide the inspector window.
• Shift-Command-P: Page setup: Display a window for selecting document settings.
• Shift-Command-S: Display the Save As dialog, or duplicate the current document.
• Shift–Command–Minus sign (-): Decrease the size of the selected item.
• Shift–Command–Plus sign (+): Increase the size of the selected item. Command–Equal sign (=) performs the same function.
• Shift–Command–Question mark (?): Open the Help menu.

Other shortcuts

For more shortcuts, check the shortcut abbreviations shown in the menus of your apps. Every app can have its own shortcuts, and shortcuts that work in one app might not work in another.

• Apple Music shortcuts: Choose Help > Keyboard shortcuts from the menu bar in the Music app.
• Other shortcuts: Choose Apple menu > System Preferences, click Keyboard, then click Shortcuts.

Learn more

• Create your own shortcuts and resolve conflicts between shortcuts
• Change the behavior of the function keys or modifier keys