iPulse Home Page | iPulse Jacket Gallery | iPulse FAQ | Iconfactory Home Page
About iPulse iPulse is an application that graphically displays the inner workings of Mac OS X.

After you start the iPulse application, several gauges are displayed in the iPulse window and dock icon. These gauges display the following items:

You can learn more about each gauge, and the information window that appears when you hover over it, by clicking on the name above. We also suggest that you start with the Introduction as it gives some useful background information.

iPulse can be configured using the application preferences—there are many different ways to display your system's information. You can also load an iPulse Jacket to quickly set the preferences (a section below explains how to create your own Jackets.)

After you become familiar with iPulse, take a look at the Tips and Tricks and Power Users sections for additional help with configuring iPulse.

Note: This page is displayed the first time you run iPulse. If you need to refer to it again, choose Help from the iPulse menu bar.

How It Works As you may be aware, Mac OS X is based on the Unix operating system. This operating system has evolved over many years into a robust and efficient computing platform. The developers of Mac OS X and its predecessors have included many mechanisms for examining the internal state of the operating system. This instrumentation allows an administrator to tune the system for optimum performance and to determine the cause of any system problems.

With iPulse, our goal was to graphically represent this internal information in a way that is both space efficient and easy to read.

So where does iPulse get this internal information? And how is it displayed graphically? The rest of this section is dedicated to answering these questions.

Introduction In order to make this help file useful for the widest group of people possible, we'll start each topic at a basic level. As we progress through the topic, the technical detail will increase—readers can skip to the next topic if they find the current one gets too difficult.

One of the major new features in this version of iPulse is the information window that appears when you hover the mouse over a gauge. The contents of this window will be discussed after a brief introduction to the gauge. In many cases, the information window helps you to learn what the gauge is doing.

After discussing the information window, we will present low-level information that will be useful for those readers who are technically inclined and want to fully understand the data. We'll be referring to Unix shell commands which can be executed from a Terminal window. If you are curious, go ahead and use the commands: none of the examples presented here can damage your Mac (just make sure you don't make any typographical errors!) You can also use man [command] to learn more about a particular command.

iPulse Gauges

The diagram above shows the location of the various gauges in the iPulse interface. Each of the gauges will be described below.

If you are looking for information on a particular gauge you can locate it quickly by looking for a marker like this: [#] (where the # is replaced by the number on the gauge.) Clicking on any marker will scroll back to this diagram. Use your browser's back button to return to the topic.

CPU Usage The first gauge we'll cover is the CPU: the heart of your Mac and iPulse's display!

Mac OS X follows the Unix convention of breaking the CPU usage down into three categories: system time, user time and nice time. The system time is the amount of time spent processing operating system tasks. User time, on the other hand, is the time spent running applications and services outside of the kernel. Nice time is the amount spent running low priority processes—these processes are "nice" because their reduced priority lets the kernel automatically lower their CPU usage when the system gets busy.

The CPU gauge is drawn with the percentage of time spent on system tasks in the inner circle [1] and the percentage of user time in the outer circle [2]. Any lower priority (nice) processes are displayed outside the user circle [3]. The number displayed on the gauge is the sum of system, user and nice time. The value is averaged over the last 10 updates.

Another feature of the CPU gauge is that it tints the display according to system load. We'll explain system load in the next topic, but you can think of this feature like an electric heating element: as your CPU "heats up", the gauge gets more color.

iPulse examines the amount of work your Mac has done over the past 15 minutes and uses the resulting value to adjust the color tint of the gauge. The end result is that you can see long term trends in CPU usage. For example, if you are performing some CPU intensive task like a Gaussian blur on a 2 GB image, you'll see the CPU gauge get redder (it's hot!) When the CPU gauge returns to the normal color, you'll know that your processing task is complete.

Each iPulse gauge displays an information window when you hover your mouse over the gauge. This helps you learn where each of the gauges is located. After you use iPulse for awhile, you won't have any problem remembering, but at first it can be a bit difficult to associate the gauge with the item it represents.

The CPU information window displays the following items:
  • Load - the current system load (averaged for the past minute) along with the minimum, maximum and average loads from the past hour.
  • Processes - the number of processes that are currently active, broken down into those that are running, sleeping, or in some other state. The processes labeled "root" are processes that iPulse can't examine because it doesn't have the appropriate permissions—you can manually change iPulse's permissions so that it can report more accurate process information. See the Power Users section below for more information.
  • Temperature - the current temperature as reported by a sensor on the CPU chip. Some Macs don't report this information (most notably, the latest PowerMac G4 desktops.) Even when the CPU temperature is reported, it's not extremely accurate: the values tend to be lower than the real temperature. It's best to think of this value as a relative value. The maximum operating temperature for the G4 chip is 101 °C—if you see this value displayed, run for your life! :-)
  • Usage - the CPU usage is broken down into percentage values for each of the categories mentioned above. By default, the total value will not include the low priority processes (there is a preference to change this.)
  • Process listing - The last piece of information is the list of processes sorted by average CPU usage. The busiest application is at the top of the list. The process number (also called a process id or procid) is also displayed for us Unix geeks.

You can obtain similar information using the top command in a Terminal window. In fact, if you find iPulse reporting something unexpected, like a process using more CPU time than normal, you can use top to start investigating the problem. The process number reported in the information window can also be used with ps -p # (where # is the process number.)

The CPU usage statistics are retrieved using the host_statistics() system call with the HOST_CPU_LOAD_INFO selector.

System load Another measure of CPU usage in the land of Unix is the "load average". The load average is a metric which represents the average number of processes waiting for the CPU over a period of time. As the CPU load increases, so does the load average.

You can think of the load average like a line at a bank. There are customers (processes) who need to interact with a teller (processor.) There can be more than one teller (multiple processors.) As the line (process queue) gets longer, the tellers have more work to do. At lunch time, when there are more customers waiting for service, the teller's load average will be higher than it is at other times of the day.

The History gauge shows the load average as a ring of dots around the outside of the iPulse window [19]. This gives an overall view of the load for the past hour. The current minute is represented by an unfilled dot; the other dots show the load average relative to the current minute. For example, the five dots that are counter-clockwise from the unfilled dot show the past five minutes.

An opaque dot indicates a minute of high activity (checking your mail, running a heavy-duty operation in Photoshop, or something else which consumes a lot of the CPU.) Alternatively, a transparent dot indicates a period of low CPU load. Your coffee break, for example.

The display of the load average can be adjusted in the History pane of the preferences window. The slider for the minimum load average sets the lowest load average that will be displayed (any load average below this value will be transparent.) The maximum load average is the level at which the dots become opaque. These preferences are also used for the CPU tint feature mentioned above.

There is no information window for the History gauge. You can see the load average statistics by hovering over the CPU gauge.

Both uptime and top will show you the current load averages in a Terminal window. They report the load averages over a period of 1, 5 and 15 minutes.

iPulse retrieves the CPU load using the host_statistics() system call with the HOST_LOAD_INFO selector.

Memory Usage Mac OS X has a very sophisticated mechanism for managing virtual memory. If you were ever unlucky enough to have experienced virtual memory in OS 9, you'll appreciate this sophistication!

The virtual memory in Mac OS X is managed by dividing physical memory usage into four categories: wired, active, inactive and free. Each of these categories is accounted for in 4 kb blocks of memory called pages. The categories are described below:

  • Wired [4] - these pages represent the memory being used by the Unix kernel. These pages are "locked in place" and will never be unloaded from physical memory. Applications have an indirect effect on wired memory usage since this is where the kernel stores and manages data about processes, threads, and libraries.
  • Active [5] - active pages indicate physical memory which has been recently accessed. These pages are mapped (accessible) to an application.
  • Inactive [6] - inactive pages are those that have not been accessed recently. The data in the inactive pages is valid, but may not be mapped to an application. Inactive pages will either be made active (mapped to the application) or be moved from physical memory to disk (to make room for new pages.)
  • Free [7] - these pages are not in use by any part of the system and can be assigned to an application immediately.
There are several "pagers" in Mac OS X that periodically check the state of each category and moves memory pages from one group to another. The algorithms behind this mechanism are beyond the scope of this document; search the Apple Developer site for "VM pager" and you'll see all the gory details. This website also has more general information on the virtual memory subsystem.

When iPulse graphs the memory usage, it breaks the four groups above into two colored bands representing "in use" and "available" memory. The "in use" band of color shows the wired amount (left-most) and active memory. Memory that is "available", represented by inactive and free memory (right-most), is shown in the other band of color.

When you hover over the gauge with your mouse, an indicator will highlight which category of memory you are viewing and how much space is allocated. After the summary, you'll see a list of the processes (applications) that are using the most memory. The list shows the amount of physical memory in use (resident usage) as both an amount and a percentage of total memory. The total amount of memory used by the application (virtual memory) is also shown.

Again, the top command in a Terminal window shows this information and provides more detail about how the memory is distributed within the process. The vm_stat command also gives more detailed information about how virtual memory is being used.

iPulse calls host_statistics() with the HOST_VM_INFO selector to gather the memory information from the Unix kernel.

Memory Swapping Memory swapping (or "paging") is the act of moving memory pages from physical memory to the hard disk. This is an operation that uses a lot of system resources: memory must be read and copied to the disk. If you're swapping, your Mac doesn't have much time for other important tasks (like a game of Unreal Tournament.)

Swapping in (also called pagein) occurs when an application needs to access a memory page, and the page is not active or inactive. The page must be read in from the disk. Likewise, inactive pages will be swapped out (pageout) and written to disk in order to make room for new requests for memory.

You'll notice this behavior when using Mac OS X: when you have many applications running, and memory becomes full, you'll notice delays and disk activity when you switch between applications. This is caused by memory pages being swapped in for the new application, while pages from an older application are swapped out to disk.

If you are experiencing a lot of swapping activity, it's a good sign that you need to purchase more memory for your Mac!

The gauges for pages being swapped in and out show activity in one page increments up to a maximum of 90 (one page per degree of arc on the gauge.) Pages that are swapped in are displayed on the left [16] and pages swapped out are displayed on the right [17]. The text on the graph shows the number of pages swapped.

When you hover over the swapping gauges, you'll see an information window with summary of the paging activity. There is also a report of how many files are being used for storing memory on disk; having a lot of "swapfile" usage indicates that virtual memory is getting fragmented and a reboot may be in order.

The list of processes is sorted by two important pieces of information:

  • Pageins - the number of pages each process caused to be read from disk into memory.
  • Faults - the number of pages that needed to be accessed but were not active. This is an indicator of which applications are actively using memory. Having a high fault count is not necessarily a bad thing.

iPulse calls host_statistics() with the HOST_VM_INFO selector to gather the memory information from the Unix kernel.

Disk Usage iPulse shows a disk usage gauge, giving you a quick overview of how much space is in use. When you use applications like iMovie, iPhoto and iTunes, free space can often be in short supply!

To minimize clutter in the gauge, only disks (filesystems) that are read/write are displayed. CD-ROMs and other read-only media are not displayed. Network disks are displayed in the gauge after you connect to the server.

The amount of disk space used [10] and the amount of free space [9] are both displayed in a clockwise manner. When the amount of disk space used exceeds 90%, the gauge is displayed with a warning color. iPulse limits the usage display to the first six disks that are connected. The first disk in the list is the one used to load Mac OS X and is labeled "(Root)" following standard Unix conventions.

In version 2.0, a new feature was added to show the sum of all disks—iPulse computes the amount of space used by all disks and displays the result. If you have many disks, this is often a better option than showing them individually.

When you hover over the disk usage gauge, you'll see a summary that shows each disk and how much space is in use. The list also shows the kind of file system used on the disk. The file system can be one of the following:

  • hfs - Hierarchical file system. The traditional Mac file system.
  • webdav - Web-based Distributed Authoring and Versioning file system. We're glad Apple chose to call it iDisk instead!
  • smbfs - Server Message Block file system. Used by Windows to share files on a network.
  • ufs - Unix file system. Used since the dawn of time, when a 1 MB disk was hearty.
  • msdos - MS-DOS file system. For all your floppy needs!
  • nfs - Network file system. A file sharing mechanism commonly used on Unix and Linux.
  • udf - Universal Disk Format file system. Used for CD and DVD recordings.

The df -k command in a Terminal window shows the disk usage for all mounted filesystems (including read-only and device filesystems.)

The disk statistics are gathered by calling getmntinfo().

Disk Activity The disk usage gauge described above shows fairly static information about how the disk is being used. The disk activity gauge, on the other hand, shows how the disk is being used by the system. The gauge displays an indicator for every read or write operation performed by the Unix kernel. It also display the amount of data transferred.

The read activity is displayed as a dot on the left side of the gauge [8] while the write activity is displayed as a dot on the right [11]. When the dot is displayed, it indicates that there was a read or write operation during the last update period. If there are more than 100 operations performed, the dot is displayed in the highlight color to indicate that there is a higher level of activity.

The number of bytes transferred to or from the disk is shown as a bar graph under the activity indicator. The scale for the graph can be set to fixed, logarithmic or automatic—these options are described in the preferences section. You can configure the bar graph so that it displays a line at the peak value for disk reads/writes.

The bar graph also includes a peak indicator. iPulse keeps track of the maximum number of bytes over a period of time and will display a small line at this peak value. Initially, the peak will be held for one minute; you can adjust the hold time in Global preferences.

When you hover over the gauge, you'll be shown a summary of the read and write operations. The summary includes the number of operations and bytes per second transferred during the last update period. The current peak and average values are also displayed.

The disk activity information is obtained from IOKit using the "IOBlockStorageDriver" selector.

Network Activity When designing iPulse, one of the issues we struggled with was what kind of networking information to show. There is a lot of network information available from the kernel. In the end, we decided that two types of information were most useful:

  • IP activity - the number of packets sent and received by IP (Internet Protocol). This lets you see activity caused by any IP packet (even if it's not a TCP packet.)
  • TCP bandwidth - the number of bytes sent and received by TCP (Transmission Control Protocol.) This allows you to see the amount of data you are transferring while doing common tasks like moving files between servers, surfing the web and reading e-mail.

iPulse draws incoming network traffic on the left [12,13] and outgoing traffic on the right [14,15]. The bar graph displays the number of bytes of data per second [13,14]. The scale for the graph is either fixed, logarithmic or automatic, depending on the preference setting. The bar graph can also be configured to display a line at the peak network traffic.

The dot at the beginning of the bar graph is displayed if there are any IP packets received [12,15]. The dot is highlighted if there are more than 25 packets per second.

When you hover over the gauge, you'll be shown a summary of the network traffic. The summary includes the number of packets transferred along with the bytes per second during the update period. The current peak and average values are also displayed.

The information window also shows the current hostname along with some basic network configuration information (interface name and associated IP address.)

You can see the network activity using the Terminal command line using the netstat -I [interface] command with the named interface (such as en0 for Ethernet and en1 for Airport.) Additional network configuration information can be retrieved with ifconfig -a -u.

The network information is retrieved using the sysctlbyname() system call. The TCP statistics are retrieved using the "net.inet.tcp.stats" selector, the IP statistics with the "net.inet.ip.stats" selector. If you didn't believe our earlier statement about there being a lot of networking information, try sysctl -A net.

Mobility If you have a Mac with either a battery or wireless Ethernet (AirPort), you'll see some additional gauges. One displays the current battery power level [18], and the other displays the wireless signal strength [20].

The battery gauge displays six dots when the battery is full and no dots when the battery is empty. When the battery level falls below 10%, the background is highlighted (the default color is red, giving you a visual clue to save your work!)

As the battery charges, the dots are shown in orange. When the battery is full and the dots turn green. This coloring matches the standard power adaptor, but if you'd like something different, you can change the colors with the Mobility preference pane.

Wireless signal strength is displayed in a similar manner. Maximum signal strength is displayed as six dots, while no signal shows no dots. If the signal strength dips below 10%, the background is highlighted—alerting you that it's time to find a new seat in the coffee house!

The information window for both of these gauges displays additional information about the battery and wireless connection. The battery's voltage and amount of current being drawn is shown along with an estimate of the time remaining. The wireless information includes the access point name and ID along with the signal-to-noise ratio.

The battery information is obtained from IOPMCopyBatteryInfo. Wireless information comes from the undocumented Apple80211 framework.

Clock The clock shows the current time.

With the default preference settings, it should be pretty obvious how the data is displayed. The 24-hour settings change the face of the clock so that it shows a unique position for every hour of the day. The 24-hour clock predates mechanical timepieces—it was originally used on the face of a sundial.

The clock can also include a date indicator. The preferences allow you to set the month, day, date or moon phase as the indicator. The moon phase divides the year into 12 periods (approximately). If you have ever wondered why the number 12 appears frequently in timekeeping, you can blame it on the moon!

A feature to ring on the hour can also be configured. Instructions for adding your own sounds can be found in the Tips and Tricks section.

When you hover over the date (at the 12 o'clock position) the clock information window is shown. This window displays the numeric time and date (along with the time zone and GMT/UTC offset.) A calendar with the current week and date highlighted is also shown.

The information window also displays the amount of time since you last restarted Mac OS X (commonly referred to as uptime.) Those of you who enjoy gazing at the stars will also appreciate the Julian date and details about the moon phase.

The time is acquired by a call to the time() system call. The time is converted to a local time with localtime(). The moon phase calculations are derived from the work originally done by John Walker—a visit to his Earth and Moon Viewer is highly recommended.

General Information And last, but not least, iPulse will display some general information when you're hovering over a part of the window without a gauge.

The information includes the name of the computer and your login names (both the long and short versions.) The iPulse and Mac OS X versions are also displayed along with the amount of time iPulse has been running.

Finally, the general information shows if mouse clicks are being ignored. This allows you to see if clicking on the iPulse window will actually do anything :-)

Preferences There are a lot of preferences for iPulse. Instead of explaining each one in excruciating detail, we'll just highlight some of the major features. We'll also focus on the preferences that are less obvious.

Using Jackets A quick way to change your preference settings is to load an iPulse Jacket. After starting iPulse, all you need to do is double-click on the Jacket (with the .ipulse file extension) and the settings contained in the file will be applied.

The iPulse folder you downloaded contains several sample Jackets. We have also created an online gallery with additional Jackets. This gallery will be updated periodically—there is a handy link in the Help menu to check the web page.

If you make any changes to a Jacket, you should save a copy. Just go to the Main preference pane and click on the Save Settings button. Then select a file name, press OK, and you'll have a new Jacket with your updated settings.

Turning gauges on and off All of the gauges can be turned off and on with the click of a checkbox. This lets you quickly trim iPulse's display to suit your needs.

Opacity All of the color wells in iPulse support opacity. This allows you to not only adjust the color you see in the gauge, but also how much color you see.

To adjust the opacity of the gauge, just click on the color well control. In the color adjustment window, drag the opacity slider from 0% (completely transparent) to 100% (fully opaque.) You'll immediately see the change in the gauge.

Adjusting a gauge's opacity to 0% is a simple way to hide parts of the iPulse gauges. As an example, you can set the window background to 0% and have the gauges floating above your desktop. This also works for the disk and mobility backgrounds. Likewise, if you want to see the amount of memory in use, but not the amount available, you can set the opacity for available memory to 0%.

Text on gauges Most gauges have the option of showing text on the gauge. By default, the text is only displayed on the floating window—a preference in the Global pane lets you put the text on the dock icon, too.

Activity scaleBoth disk and network activity have a preference to scale the gauge. The scaling types are:

  • Fixed - The scale is determined by the value you select in the pop-up menu. For example, if you select "100K bytes per second", the gauge being completely full indicates that there is 100KB of activity in the past second. If the gauge is half full (45° of the 90° arc) then this indicates that there's 50KB of activity.
  • Automatic - This scale is much like the fixed scale described above, except that the maximum scale value adjusts automatically. The adjustment is made using the current peak value. As an example, if the peak activity is currently 75KB per second, then the gauge scale is set to the next higher power of ten—100KB per second.
  • Logarithmic - This scale divides the gauge into three sections, each of which displays a range of data for a power of ten. For example, if you select a logarithmic scale of 10K to 1M per second, values between 1K and 10K are displayed in the first 30°, values between 10K and 100K in the second 30° arc, and values between 100K and 1M per second in the remaining 30°. If activity goes below 1K bytes per second, nothing is displayed—with activity above 1M bytes/second the entire gauge is filled.
Additionally, the automatic scale displays a series of dots on the gauge to give you an indication of the current scale. There are no dots at 1K, one dot at 10K, two dots at 100K and so on. Likewise, the logarithmic scale displays a thin divider between each of the three ranges, giving you an idea of how much the data is being scaled.

Peak indicators The peak indicators can be configured for the disk and network activity gauges. These indicators behave like the level meters on some audio recording equipment.

The indicators work by keeping track of a maximum activity level over period of time. This maximum value is displayed as a thin line on the gauge.

You can control how long the maximum activity level is displayed (held) in the preferences Global pane. If you are using an automatic scale for activity, adjusting the peak hold time will also affect how often the scale is adjusted.

Load scaling If you choose to display the history gauge, it's likely that you'll need to to adjust the minimum and maximum load averages. The default values will be fine for a wide range of machines, but fine tuning the settings will allow for a more accurate display on your own machine—be it an iBook or a dual processor G5.

The first thing you'll want to do is hover over the CPU gauge so the information window appears. At the top of the information window, you'll see a line of information labelled "Load" with min and max values. These values should be used as starting point when you set values in the History preference pane.

You'll notice that the opacity of the history dots changes as you adjust the minimum and maximum sliders. The minimum load average sets the lowest load average that will be displayed (any load average below this value will be transparent.) The maximum load average is the level at which the dots become opaque.

These preferences are also used to adjust the tint on the CPU gauge. The tint is transparent (not shown) at the minimum load value. When the load is at maximum, tint's opacity is displayed fully.

Decoration One of the more popular features of this version of iPulse is the ability to add a background image. You can add pretty much anything you like behind the iPulse gauges. That combined with the ability to adjust the gauge's opacity, give you quite a bit of freedom to change iPulse's look.

See the following section on creating Jackets for information on the format and size of the background image.

Units The display units used by iPulse can be set in the Global preferences. The formats are:

  • Apple- The Finder displays binary values with two uppercase characters. For example, 2^10 = 1024 = 1 KB.
  • IEEE - The IEEE standard uses an uppercase unit followed by a "b" (to indicate byte). So 2^10 = 1024 = 1 Kb.
  • SI binary - SI units (also known as the International System of Units) defines a standard set of prefixes for measurement. Even if you live in a country that stubbornly refuses to use the metric system, you are familiar with kilograms, megahertz and gigawatts to measure units in powers of 10. These prefixes have been modified to measure powers of 2 so that 2^10 = 1024 = 1 KiB. This format is explained in more detail here.

Ignoring mouse In the Window preference pane, there are several adjustments that should be fairly obvious. The one that's not is "Ignore mouse clicks."

This is a new feature in this version of iPulse. After you enable the checkbox, mouse clicks in the iPulse floating window will be ignored and passed onto the application below. This allows you to click on scroll bars, the desktop or whatever else is behind iPulse.

The only drawback to this feature is that it's hard to move the iPulse window since it ignores your clicks. That leads us to our next topic...

Setting hotkeys iPulse allows you to set two hotkeys. One of these hotkeys shows or hides the iPulse floating window. The other hotkey toggles the "ignore mouse" feature discussed above.

By default, the hotkeys are not enabled. You'll need to go to the Global preferences and press on the "Set..." button. In the window that appears, press the key combination or function key you want to assign and press OK. Be careful that you don't assign a key combination that's used in another application. If you assign Command-C to the hot key, you'll get iPulse instead of a clipboard copy!

After you've set the hotkey, you can use the hotkeys in any application. The show/hide hotkey is useful if you want to get rid of iPulse for a presentation, game or any other full-screen activity where it would be in the way. If you are using the "ignore mouse" feature, you can use the hotkey to quickly enable the mouse, move iPulse's floating window, and then disable the mouse again.

Hide iPulse in listings Finally, in the Global preferences, there's a preference to include iPulse in the process listings. We recommend that you do not use this feature.

The reason is not because we don't want you to know how much CPU iPulse is using; it's because a process that monitors itself is notoriously inaccurate. If you want an accurate estimate of how much time iPulse is using, please use top from a Terminal window.

If you think iPulse is using too much CPU time, please check the Tips and Tricks section for ways to lower its usage.

Creating Jackets If you'd like to create your own iPulse Jackets and distribute them to your friends or make them a download on your website, here are a few simple instructions that will help you out:

Background Image The most visually striking part of an iPulse Jacket is the image used behind the gauges. You can set any TIFF, JPG, PNG, GIF, PDF or ICNS file as the background using the controls on the Other preference pane. If you use the TIFF format, make sure that there aren't any alpha channels or layers in the file.

The image file's dimensions should be 128 x 128 pixels (it will be scaled automatically when the user changes the iPulse window size.) The gauges are positioned in even divisions of 128 pixels—8, 16, and 32 pixels. The circle is divided up like a clock—12 sections of 30° each.

Save Settings After you have configured your iPulse settings the way you want, create the Jacket by going to the Main preference pane and clicking on Save Settings. This will create a .ipulse file (Jacket) that contains the settings.

Be aware that the Jacket does not contain the preferences from the Window or Global panes. These preferences, which contain hotkeys, window sizes, and other configuration items, are considered personal settings and are not updated when another iPulse user loads your Jacket.

Tips and Tricks This section will give you some ideas on how to configure iPulse on your own system.

Start iPulse at login You can configure iPulse to launch automatically using the Login Items of the System Preferences.

Lower iPulse CPU usage On an older Mac, you may be concerned about iPulse's CPU usage. Here are a few tips for making iPulse run as efficiently as possible:

  • Longer time between updates - In the Global preference pane, there is a setting for the amount of time between updates. Since the majority of iPulse CPU usage is collecting information required by the update, you can significantly reduce the overhead by changing the speed from the default of one second to two seconds (or even three seconds.)
  • Lower iPulse priority - Another setting to check in the Global pane is the process priority for iPulse. Make sure that the priority is lowered (the default is +5 nice.) When iPulse's priority is lowered, other applications will be given more CPU time when things get busy. Another benefit, in periods of high activity, is that iPulse will automatically update less frequently—giving the CPU even more time to run other tasks.
  • Turn off shadow for floating window - If you have a shadow on your iPulse window, try turning it off. It won't look as nice, but it will require less CPU time since the shadow does not need to be recomputed at each update.
  • Turn off information window fading - Set the information window fade in/out to "None". The window will appear faster and it will use less CPU time to display.

Add your own sounds To use your own sounds for the "ring on hour" feature, add AIFF sound files to your ~/Library/Sounds folder. Files with the extension ".aiff" will appear in the list of sound names after you restart iPulse.

To create the AIFF sound file, you can use the QuickTime Player to open an MP3, movie or other media file. Select the portion you want using the slider controls at the bottom of the time window. Then use Edit > Trim followed by File > Export to save the selected portion in the audio file. Make sure that "Sound to AIFF" is selected in the pop-up menu when you export.

Running iPulse without a dock icon Normally, iPulse displays with an icon in the dock. You can configure iPulse to run as an application in "background mode" which will prevent the application icon from appearing in the dock.

When you run an application in background mode, you need to be aware of several limitations:

  • There is no menu bar for the application. The command keys will still work, so you can quit the application (Command-Q) or display preferences (Command-Comma). You can also use the context menu that appears when you control-click on the iPulse window to access these functions.
  • iPulse will not appear in the Force Quit menu when you use Command-Option-Escape. You will need to use a Terminal window to manually kill the iPulse process.
  • Since the changes required are to the application's configuration, all users on the machine must use iPulse in background mode.
Before making the change to background mode, make sure that the iPulse window is displayed on the desktop.

To configure iPulse to run in background mode, open the application package using a control-click on the application icon and selecting "Show Package Contents". Find the Info.plist file in the Contents folder and open it with TextEdit. Locate the LSUIElement and change the "<string>0</string>" to "<string>1</string>". Save the file and return to the Contents folder.

If you are running on Mac OS X 10.2, can just restart iPulse at this point. If you are running on 10.3 (Panther), the Launch Services information contained in the Info.plist file is cached, so you'll need to create a new application and update the cache. The easiest way to do this is to select iPulse in the Finder and duplicate the file (using Command-D.) Then launch the new file (iPulse copy) and verify that it is not displayed in the Dock. At this point, the cache has been updated, so you can quit iPulse and return to the Finder. Delete the original iPulse file and rename "iPulse copy" to "iPulse".

If you decide you don't want to run in background mode, change the LSUIElement back to it's original value of "0".

Power Users This section is dedicated to those who fear no command line. The instructions in this section assume that you are comfortable in a Terminal window. If you are not, we recommend that you skip this section.

Preferences Most of the preferences in iPulse are exposed with the panes in the Preferences window. There are, however, other preferences which can be useful, but would either clutter the user interface or be difficult for a novice user to understand.

To set one of these "power user" preferences, quit iPulse and issue the following from a command line:

% defaults write com.iconfactory.iPulse [preference] [value]
where [preference] is the name of the preference and [value] is the value to use (shown in the table below.) After restarting iPulse, you should see the new preference setting.

To delete the preference and return to a default setting, use:

% defaults delete com.iconfactory.iPulse [preference]
Make sure that you match case when typing the [preference] key—ifapplicationneverhide is not the the same as IFApplicationNeverHide. Use man defaults for moreinformation about setting defaults with the command line.

So, without further adieu, here are the power user preferences:

Preference Default Value Description
IFApplicationNeverHide 1 When this preference is set to 1, iPulse will never hide. This prevents the dock icon from dimming.
IFApplicationPlotProcessorArea 0 Normally, iPulse plots the CPU gauge with the percentage represented as an area within the circle. For example, a 50% usage will fill 50% of the circle's area. This is more visually accurate, but tends to make smaller CPU usage values look bigger. To plot the CPU as a function of the radius, change the value to 0. This will cause 50% usage to use half of the circle's radius.
IFApplicationAlwaysHoverTime 0 By default, iPulse shows the clock information even if there is no date indicator and the clock is turned off. When this preference is set to 0, the information window will only be displayed when the date indicator is displayed.
IFApplicationHideInfoOnDrag 1 Setting this preference to 1 will cause iPulse to hide the information window while you drag the floating window. This is less work for older graphics cards and can provide better response.
IFApplicationAlternativeActivity 1 Set this preference to 1 and you'll see an activity indicator that doesn't overlap the gauge to the top.
IFApplicationSwapfilesPath /var/vm This preference specifies the path to where your swapfiles are located. If you have customized your swapfile configuration, you'll need to change this from the default of /var/vm.
IFApplicationCHUDWorkaround 1 If you have the CHUD Tools installed, you'll need to set this flag, otherwise iPulse will cause the kernel to use excessive amounts of CPU time. When the flag is 1, iPulse avoids a call to host_processor_info with the PROCESSOR_TEMPERATURE temperature parameter. Newer processors, such as the G5 or the G4 chips in the iBooks and Aluminum PowerBooks, will ignore this flag since the temperature is read via IOKit instead of the Mach system call.
IFApplicationInfoDelay 0.75 By default, iPulse will use a 0.75 second delay before opening the information window (assuming the preference is set in the Windows pane.) If you'd like the delay to be longer or shorter, you can change the value to any number greater than 0.
IFApplicationTrackMouse 0 iPulse only checks the mouse position for displaying the information window at each update period (as defined in the Global timing preferences.) If you have a long update period, you may want to have iPulse track the mouse so that you can get faster feedback. This feature is not enabled by default since it uses more processor resources—each time the mouse moves, system information must be collected.
IFApplicationStatusAlertThreshold 0.9 Status values show in the menu bar are displayed in the range of 0.0 to 1.0. When the threshold defined by this parameter is exceeded, the alert color is applied. The default is to show the alert color when the display is at 90% of the maximum value.
IFApplicationIgnoreExpose 0 If you'd like iPulse to remain on the desktop when you use the Show Desktop feature in Exposé, set this preference to 1. This will make iPulse's transparent windows "sticky" like the Dock and menu bar. This feature uses undocumented calls in the Core Graphics framework, so it may not work in any release other than Panther. But it's pretty cool anyway :-)