To generate a three triangle zig-zag pattern which will be stroked three times time use the following command. G12 P1 S3 T2&#;; zig-zag pattern with 2 triangles
Notes
1In Marlin firmware and Derivatives Mk4duo this is implemented by hard-coded firmware behaviours As defined for variables NOZZLE_CLEAN_STROKES, NOZZLE_CLEAN_START_POINT, NOZZLE_CLEAN_END_POINT and NOZZLE_CLEAN_PARK.
With NOZZLE_CLEAN_PARK enabled, the nozzle will automatically return to the XYZ position after G12 is run.
More on this behaviour is documented inside of the code base.
The use of G12 for tool cleaning clashes with the established use of G12 for circular pocket milling on CNC machines. For this reason, RepRapFirmware does not support G
G Plane Selection (CNC specific)
G-code
This page tries to describe the flavour of G-codes that the RepRap firmwares use and how they work. The main target is additive fabrication using FFF processes. Codes for print head movements follow the NIST RSNGC G-code standard, so RepRap firmwares are quite usable for CNC milling and similar applications as well. See also on Wikipedia's G-code article.
There are a few different ways to prepare G-code for a printer. One method would be to use a slicing program such as Slic3r, Skeinforge or Cura. These programs import a CAD model, slice it into layers, and output the G-code required to print each layer. Slicers are the easiest way to go from a 3D model to a printed part, however the user sacrifices some flexibility when using them. Another option for G-code generation is to use a lower level library like mecode. Libraries like mecode give you precise control over the tool path, and thus are useful if you have a complex print that is not suitable for naive slicing. The final option is to just write the G-code yourself. This may be the best choice if you just need to run a few test lines while calibrating your printer.
As many different firmwares exist and their developers tend to implement new features without discussing strategies or looking what others did before them, a lot of different sub-flavours for the 3D-Printer specific codes developed over the years. This particular page is the master page for RepRap. Nowhere in here should the same code be used for two different things; there are always more numbers to use The rule is: add your new code here, then implement it.
Unfortunately human nature being what it is, the best procedures aren't always followed, so some multiple uses of the same code exist. The rule which should be followed is that later appearances of a code on this page (later than the original use of a code), are deprecated and should be changed, unless there is a good technical reason (like the general G-Code standard) why a later instance should be preferred. Note that the key date is appearance here, not date of implementation.
Introduction
A typical piece of G-code as sent to a RepRap machine might look like this:
N3 T0*57 N4 G92 E0*67 N5 G28*22 N6 G1 F*82 N7 G1 X Y F*85 N8 G1 X Y*33
G-code can also be stored in files on SD cards. A file containing RepRap G-code usually has the extension , or . Files for BFB/RapMan have the extension . G-code stored in file or produced by a slicer might look like this:
G92 E0 G28 G1 F G1 X Y F G1 X Y
The meaning of all those symbols and numbers (and more) is explained below.
Slicers will (optionally?) add G-code scripts to the beginning and end of their output file to perform specified actions before and/or after a print such as z-probing the build-area, heating/cooling the bed and hotend, performing ooze free "nozzle wipe" startup routine, switching system power on/off, and even "ejecting" parts. More info on the Start GCode routines and End GCode routines pages.
To find out which specific G-code(s) are implemented in any given firmware, there are little tables attached to the command descriptions, like this one:
Here means:
&#;???
Unknown if the firmware supports this G-code. You may want to test this yourself before using it in production.
Yes
The G-code is fully supported by the firmware.
+
The G-code is supported by version and above.
No
The firmware does not support the G-code at all.
Partial
There is only partial support for the full G-code specification. It may be required to rebuild the source code with extra options or flip configuration switches on the mainboard.
Experimental
The G-code is experimental and may change or be removed.
Automatic
The firmware handles this G-code automatically, so there's no need to send the command. An example is power supply on/off G-code (/) in the Teacup firmware.
For the technically-minded, G-code line endings are Unix Line Endings (), but will accept Windows Line Endings (), so you should not need to worry about converting between the two, but it is best practice to use Unix Line Endings where possible.
Fields
A RepRap G-code is a list of fields that are separated by white spaces or line breaks. A field can be interpreted as a command, parameter, or for any other special purpose. It consists of one letter directly followed by a number, or can be only a stand-alone letter (Flag). The letter gives information about the meaning of the field (see the list below in this section). Numbers can be integers () or fractional numbers (), depending on context. For example, an X coordinate can take integers () or fractionals (), but selecting extruder number would make no sense. In this description, the numbers in the fields are represented by as a placeholder.
In RepRapFirmware, some parameters can be followed by more than one number, with colon used to separate them. Typically this is used to specify extruder parameters, with one value provided per extruder. If only one value is provided where a value is needed for each extruder, then that value is applied to all extruders.
Letter
Meaning
Gnnn
Standard G-code command, such as move to a point
Mnnn
RepRap-defined command, such as turn on a cooling fan
Tnnn
Select tool nnn. In RepRap, a tool is typically associated with a nozzle, which may be fed by one or more extruders.
Snnn
Command parameter, such as time in seconds; temperatures; voltage to send to a motor
Pnnn
Command parameter, such as time in milliseconds; proportional (Kp) in PID Tuning
Xnnn
A X coordinate, usually to move to. This can be an Integer or Fractional number.
Ynnn
A Y coordinate, usually to move to. This can be an Integer or Fractional number.
Znnn
A Z coordinate, usually to move to. This can be an Integer or Fractional number.
U,V,W
Additional axis coordinates (RepRapFirmware)
Innn
Parameter - X-offset in arc move; integral (Ki) in PID Tuning
Jnnn
Parameter - Y-offset in arc move
Dnnn
Parameter - used for diameter; derivative (Kd) in PID Tuning
Hnnn
Parameter - used for heater number in PID Tuning
Fnnn
Feedrate in mm per minute. (Speed of print head movement)
Rnnn
Parameter - used for temperatures
Qnnn
Parameter - not currently used
Ennn
Length of extrudate. This is exactly like X, Y and Z, but for the length of filament to consume.
Nnnn
Line number. Used to request repeat transmission in the case of communications errors.
*nnn
Checksum. Used to check for communications errors.
Case sensitivity
The original NIST G-code standard requires gcode interpreters to be case-insensitive, except for characters in comments. However, not all 3D printer firmwares conform to this and some recognise uppercase command letters and parameters only.
Firmwares that are known to be case-insensitive
RepRapFirmware version and later (except within quoted strings)
Druid Firmware version by default is case-insensitive: ( M S0 = case-sensitive / M S1 = case-insensitive )
Firmwares that are known to be case-sensitive
RepRapFirmware version and earlier
Druid Firmware version for case-sensitive: M S0 = case-sensitive
Quoted strings
In RepRapFirmware, some commands support quoted strings when providing file names and other string parameters. This allows file names, WiFi passwords etc. to contain spaces, semicolons and other characters that would otherwise not be permitted. Double-quote characters are used to delimit the string, and any double-quote character within the string must be repeated.
Unfortunately, some gcode sender programs convert all characters to uppercase and don't provide any means to disable this feature. Therefore, within a quoted-string, the single-quote character is used as a flag to force the following character to lowercase. If you want to include a single quote character in the string, use two single quote characters to represent one single quote character.
Example: to add SSID MYROUTER with password to the WiFi network list, use command:
or if you can't send lowercase characters:
Using expressions in parameters
RepRapFirmware and later allow parameter values to be computed from an expression enclosed in { }. Such an expression may include constants, values from the machine object model, operators and functions. Example:
See eunic-brussels.eu#Section_Use_of_expressions_within_GCode_commands for more details.
G-code comments begin at a semicolon, and end at the end of the line:
N3 T0*57&#;; This is a comment N4 G92 E0*67 ; So is this N5 G28*22
Some firmwares also obey the CNC G-code standard, which is to enclose comments in round brackets. Comments of this form must start and end on the same line:
(Home some axes) G28 (here come the axes to be homed) X Y
Comments and white space will be ignored by your RepRap Printer. It's better to strip these out on the host computer before sending the G-code to your printer, as this saves bandwidth.
Special fields
N: Line number
Example
N
If present, the line number should be the first field in a line. For G-code stored in files on SD cards the line number is usually omitted.
If checking is supported, the RepRap firmware expects line numbers to increase by 1 each line, and if that doesn't happen it is flagged as an error. But you can reset the count using (see below).
Although supported, usage of N in Machinekit is discouraged as it serves no purpose.
*: Checksum
Example:
If present, the checksum should be the last field in a line, but before a comment. For G-code stored in files on SD cards the checksum is usually omitted.
The firmware compares the checksum against a locally-computed value. If they differ, it requests a repeat transmission of the line.
*: CRC
Example:
The 8-bit checksum provides insufficient protection against noise on the received data connection in some situations, for example where the cable from a display device runs close to an extruder cable. Therefore RepRapFirmware allows a CRC to be used in place of a checksum. If present, the CRC should be the last field in a line, but before a comment. RepRapFirmware assumes that * followed by 5 digits is a CRC, whereas * followed by 1, 2 or 3 digits is a checksum. The polynomial used is 0x as for CCITT CRC
Checking
Example
N [G Code in here] *71
The RepRap firmware checks the line number and the checksum (or CRC if supported). You can leave both of these out - RepRap will still work, but it won't do checking. You have to have both or neither though. If only one appears, it produces an error.
The checksum "cs" for a G-code string "cmd" (including its line number) is computed by exor-ing the bytes in the string up to and not including the * character as follows:
and the value is appended as a decimal integer to the command after the * character.
Conditional Execution and Loops
RepRapFirmware and later supports conditions and loops in GCode. Properties from the firmware object model (e.g. current position, current tool) can be included in controlling expressions. See eunic-brussels.eu for details.
Buffering
If buffering is supported, the RepRap firmware stores some commands in a ring buffer internally for execution. This means that there is no (appreciable) delay while a command is acknowledged and the next transmitted. In turn, this means that sequences of line segments can be plotted without a dwell between one and the next. As soon as one of these buffered commands is received it is acknowledged and stored locally. If the local buffer is full, then the acknowledgment is delayed until space for storage in the buffer is available. This is how flow control is achieved.
Typically, the following moving commands are buffered: - and -. The Teacup Firmware buffers also some setting commands: , , and . All other , or commands are not buffered.
RepRapFirmware also implements an internal queue to ensure that certain codes (like M) are executed in the right order and not when the last move has been added to the look-ahead queue.
When an unbuffered command is received it is stored, but it is not acknowledged to the host until the buffer is exhausted and then the command has been executed. Thus the host will pause at one of these commands until it has been done. Short pauses between these commands and any that might follow them do not affect the performance of the machine.
G-commands
G0 & G1: Move
&#;: Rapid Move
&#;: Linear Move
Usage
Parameters
Not all parameters need to be used, but at least one has to be used
The position to move to on the X axis
The position to move to on the Y axis
The position to move to on the Z axis
The amount to extrude between the starting point and ending point
The feedrate per minute of the move between the starting point and ending point (if supplied)
(RepRapFirmware) Flag to check if an endstop was hit ( to check, to ignore, other see note, default is )1
(RepRapFirmware) Restore point number 4
Laser cutter/engraver power. In RepRapFirmware, when not in laser mode S in interpreted the same as H.
Examples
G0 X12 &#;; move to 12mm on the X axis G0 F &#;; Set the feedrate to mm/min G1 X Y E&#;; Move to mm on the X axis and mm on the Y axis while extruding mm of material
The RepRap firmware spec treats and as the same command, since it's just as efficient as not doing so.2
Most RepRap firmwares do subtle things with feedrates.
G1 F &#;; Set feedrate to mm/min G1 X50 Y E&#;; Move and extrude
In the above example, we first set the feedrate to mm/min, then move to 50mm on X and mm on Y while extruding mm of filament between the two points.
G1 F &#;; Feedrate mm/min G1 X50 Y E F&#;; Accelerate to mm/min
However, in the above example, we set a feedrate of mm/min, then do the same move, but accelerating to mm/min. Everything stays synchronized, so extrusion accelerates right along with X and Y movement.
The RepRap spec treats the feedrate as simply another variable (like X, Y, Z, and E) to be linearly interpolated. This gives complete control over the acceleration and deceleration of the printer head in a way that ensures everything moves smoothly together and the right volume of material is extruded at all points.3
To reverse the extruder by a given amount (for example to reduce its internal pressure while it does an in-air movement so that it doesn't dribble) simply use or to send an value that is less than the currently extruded length.
Notes
1Some firmwares allow for the RepRap to enable or disable the "sensing" of endstops during a move. Please check with whatever firmware you are using to see if they support the parameter in this way, as damage may occur if you assume incorrectly. In RepRapFirmware, using the or parameter on a delta printer causes the parameters to refer to the individual tower motor positions instead of the head position, and to enable endstop detection as well if the parameter is H1. H3 may be used to measure axis lengths and H4 can be used to stop when an endstop is hit while updating the position only (H4 is supported in b4 and later).
2In the RSNGC Spec, is Rapid Move, which was used to move between the current point in space and the new point as quickly and efficiently as possible, and is Controlled Move, which was used to move between the current point in space and the new point as precise as possible. In RepRapFirmware, G1 is always a linear move but G0 may not be linear (e.g. on a SCARA machine); however a G0 move will never go below the lower of the initial and final Z height of the move.
3Some firmwares may not support setting the feedrate inline with a move.
4RepRapFirmware provides an additional 'R' parameter to tell the machine to add the coordinates of the specified restore point to all axis coordinates mentioned in the G0 or G1 command. Axes that are not mentioned in the G0 or G1 command are not moved. When a print is paused, the coordinates are saved in restore point #1. When a tool change is commenced, the coordinates are saved in restore point #2. Coordinates can also be saved in restore points explicity using the G60 command.
Some older machines, CNC or otherwise, used to move faster if they did not move in a straight line. This is also true for some non-Cartesian printers, like delta or polar printers, which move easier and faster in a curve.
G2 & G3: Controlled Arc Move
Usage
(Clockwise Arc)
(Counter-Clockwise Arc)
Parameters
The position to move to on the X axis
The position to move to on the Y axis
The point in X space from the current X position to maintain a constant distance from
The point in Y space from the current Y position to maintain a constant distance from
The amount to extrude between the starting point and ending point
The feedrate per minute of the move between the starting point and ending point (if supplied)
Examples
G2 X Y I5 J10 E
(Move in a Clockwise arc from the current point to point (X=,Y=), with a center point at (X=current_X+5, Y=current_Y+10), extruding mm of material between starting and stopping)
G3 X Y I5 J10 E
(Move in a Counter-Clockwise arc from the current point to point (X=,Y=), with a center point at (X=current_X+5, Y=current_Y+10), extruding mm of material between starting and stopping)
Notes
1In Marlin Firmware not implemented for DELTA printers.
2Prusa Firmware implements arcs only in Cartesian XY.
3On Klipper, a section must be enabled in the configuration file.
G4: Dwell
Pause the machine for a period of time.
Parameters
Time to wait, in milliseconds (In Teacup, P0, wait until all previous moves are finished)
Time to wait, in seconds (Only on Repetier, Marlin, Prusa, Smoothieware, and RepRapFirmware and later)
Example
G4 P
In this case sit still doing nothing for milliseconds. During delays the state of the machine (for example the temperatures of its extruders) will still be preserved and controlled.
On Marlin, Smoothie and RepRapFirmware, the "S" parameter will wait for seconds, while the "P" parameter will wait for milliseconds. "G4 S2" and "G4 P" are equivalent.
G6: Direct Stepper Move
Perform a direct, uninterpolated, and non-kinematic synchronized move of one or more steppers directly. Units may be linear (e.g., mm or inches on ) or specified in degrees (SCARA). This command is useful for initialization, diagnostics, and calibration, and should be disabled on production equipment. This type of move can be potentially dangerous, especially for deltabots, so implementations should do their best to limit movement to prevent twerking and damaging the carriage assembly.
Parameters
Stepper A position or angle
Stepper B position or angle
Stepper C position or angle
Relative move flag
SCARA Examples
G6 A45 &#;; Move SCARA A stepper to the 45° position G6 B20 R &#;; Move SCARA B stepper 20° counter-clockwise
DELTA Example
G6 C10 R &#;; Move DELTA C carriage up by 10mm
G Set tool Offset and/or workplace coordinates and/or tool temperatures
Usage
1
Parameters
Tool number
Offset mode 5
X offset
Y offset
Z offset2
other axis offsets4
Standby temperature(s) (RepRapFirmware)
Active temperature(s) (RepRapFirmware)
Examples
G10 L1 P2 X Y Z
(sets the offset for tool 2 to the X, Y, and Z values specified)
G10 P1 R S
(RepRapFirmware only - set standby and active temperatures3 for tool 1)
Remember that any parameter that you don't specify will automatically be set to the last value for that parameter. That usually means that you want explicitly to set Z RepRapFirmware will report the tool parameters if only the tool number is specified.
The precise meaning of the X, Y (and other offset) values is: with no offset this tool is at this position relative to where a tool with offset (0, 0, 0) would be. So if the tool is 10mm to the left of a zero-offset tool the X value would be , and so on.
The value is the standby temperature in oC that will be used for the tool, and the value is its operating temperature. If you don't want the tool to be at a different temperature when not in use, set both values the same. See the T code (select tool) below. In tools with multiple heaters the temperatures for them all are specified thus: R S .
See also .
Notes
1Marlin uses G10/G11 for executing a retraction/unretraction move. Smoothie uses for retract and for setting workspace coordinates. RepRapFirmware interprets a G10 command with no P or L parameter as a retraction command.
2It's usually a bad idea to put a non-zero value in as well unless the tools are loaded and unloaded by some sort of tool changer or are on indepedent carriages. When all the tools are in the machine at once they should all be set to the same Z height.
3If the absolute zero temperature () is passed as active and standby temperatures, RepRapFirmware will only switch off the tool heater(s) without changing their preset active or standby temperatures. RepRapFirmware-dc42 does not support this setting.
4Tool offsets are applied after any X axis mapping has been performed. Therefore if for example you map X to U in your command to create the tool, you should specify a U offset not an X offset. If you map X to both X and U, you can specify both offsets. (Not supported on all firmwares).
5L1 sets the offsets of the specified tool relative to the head reference point to the specified values. L2 sets the current workplace coordinate offsets to the specified values. L20 adjusts the current workplace coordinate offsets so that the current tool head position has the specified coordinates. NOTE on some firmwares L is required (and is required by NIST standard). P is also required to specify either the tool to update or the WCS to update.
G Retract
Parameters
retract length (S1 = long retract, S0 = short retract = default) (Repetier only)
Example
G10
Retracts filament according to settings of (Marlin, RepRapFirmware) or according to the value (Repetier).
RepRapFirmware recognizes as a command to set tool offsets and/or temperatures if the parameter is present, and as a retraction command if it is absent.
G Unretract
Parameters
retract length (S1 = long retract, S0 = short retract = default) (Repetier only)
Example
G11
Unretracts/recovers filament according to settings of (Marlin, RepRapFirmware) or according to the value (Repetier).
G Clean Tool
Usage
[P<0
iPad Pro
Supercharged by
Astonishing performance. Incredibly advanced displays. Superfast wireless connectivity. Next-level Apple Pencil capabilities. Powerful new features in iPadOS. The ultimate iPad experience.
Three iPad Pros displaying apps, left is showing Logic Pro for iPad, right is showing Octane X, and center iPad is showing Final Cut Pro for iPad and is attached to the Magic Keyboard
Logic Pro for iPad
Final Cut Pro for iPad
Octane Xon iPad pro
Shown above: Logic Pro for iPad, Final Cut Pro for iPad, Octane X.
M2 chip.
The M2 chip is the next generation of Apple silicon, with an 8&#x;core CPU that delivers up to 15 percent faster performance and a 10&#x;core GPU that provides up to 35 percent faster graphics performance. With a 40 percent faster Neural Engine to accelerate machine learning tasks and 50 percent more memory bandwidth, M2 brings astonishing performance and new capabilities to iPad Pro. So you can create photorealistic 3D designs, build intricate AR models, and play games with console‑quality graphics at high frame rates faster than ever. All while enjoying all&#x;day battery life.
A complete movie studio in your hands.
The high‑performance media engine on M2 accelerates ProRes encode and decode. So you can convert video projects to ProRes up to 3x faster than before.
ProRes video capture.
Now you can capture ProRes video using the image signal processor in M2 and advanced cameras on iPad Pro. Five studio‑quality microphones and four-speaker audio with support for Dolby Atmos let you record and deliver theater‑like sound. And with Final Cut Pro for iPad, you can capture in ProRes and get the highest video quality with amazing real-time performance for tasks like multistream editing.
Final Cut Pro for iPad
nitsfull-screen brightness
nitspeak brightness (HDR)
True Tonefor comfortable viewing
1,,contrast ratio
ProMotionadaptive Hz refresh rate
Mini&#x;LEDs on iPad Pro
Powered by over10,mini&#x;LEDs
Mini&#x;LEDs.
To achieve extremely high brightness, we used an array of LEDs across the entire back of the display. To fit them in the incredibly thin iPad Pro, we used custom&#x;designed mini&#x;LEDs that are times smaller than in previous generations. Custom&#x;size optical films and diffusers mix the light more efficiently and fit in a design that’s just mm thin.
Mini&#x;LEDs on iPad Pro
Local dimming zones on iPad Pro
Overlocal dimming zones
Local dimming zones.
Over 10, mini&#x;LEDs are grouped into more than local dimming zones. Depending on the content, the brightness in each zone can be precisely adjusted to achieve an astonishing 1,, contrast ratio. Even the most detailed HDR content with the finest specular highlights — like galaxies and action movie explosions — are more true to life than ever.
The Liquid Retina display on the 11&#x;inch iPad Pro is not only gorgeous and portable, it also features incredibly advanced technologies. Like ProMotion, True Tone, P3 wide color, and ultralow reflectivity, which make everything feel responsive and look stunning.
nitspeak brightness
True Tonefor comfortable viewing
ProMotionadaptive Hz refresh rate
iPadOS. Expand what’s possible.
Enhanced ways to work.
iPadOS gives you powerful new ways to do more than ever. Desktop-class apps make your workday more productive. Resize and overlap apps to multitask like a pro with Stage Manager. And hook up an external display, with resolutions up to 6K, for even more room for all your apps.
See what’s new in iPadOS
Up to40Gb/sdata transfer speeds with Thunderbolt
Cameras. Capture and connect. On a deeper level.
Front-facing camera.
iPad Pro features an Ultra Wide camera with a 12MP sensor and a ‑degree field of view, perfect for capturing photos and video for social posts, FaceTime calls with Center Stage, or epic Portrait mode selfies. And it works with the TrueDepth camera to securely unlock iPad Pro with Face ID.
TrueDepthunlocks iPad with Face ID
Procreate
Center Stage.
Using the Ultra Wide camera and machine learning, Center Stage changes the way you participate in video calls. As you move around, it automatically adjusts to keep you centered in the frame. When others join in or leave the call, the view expands or zooms in. Center Stage works with FaceTime and other video conferencing apps for an even more engaging experience.
Rear-facing cameras
Wide camera
Ultra Wide camera
LiDAR Scanner
Pro cameras.
Advanced Wide and Ultra Wide cameras help you capture the perfect photo or video. And now with support for ProRes video capture, iPad Pro is a complete mobile video studio. The more powerful ISP in the M2 chip also supports Smart HDR 4, so photos shot on iPad look even more true to life.
LiDAR.
The LiDAR Scanner measures how long it takes light to reflect back from objects, so it can create a depth map of any space you’re in and unlock immersive AR experiences. And it works with the powerful ISP to more accurately focus images and videos in low&#x;light conditions and reduce capture time.
Polycam
Planner 5D
Wi&#x;Fi 6E and 5G. Fast friends.
Blazing&#x;fast connections.
iPad has always been uniquely portable with superfast Wi&#x;Fi and cellular options. With Wi&#x;Fi 6E, you’ve got the fastest wireless connection available. So you’ll get faster transfers of photos, documents, and large video files.
Up to2xfaster than previous generation
5G.
With 5G capabilities, you can connect to the fastest wireless networks when you need to download files, stream movies, collaborate with colleagues, and upload content on the go. And iPad Pro has the most 5G bands of any device of its kind — so it can get 5G in more places.
Learn more about cellular for iPad
Apple TV+
Magic Keyboard. Apple Pencil. Endless possibilities.
Pro accessories.
Apple Pencil, Magic Keyboard, and the Smart Keyboard Folio open up even more ways to use iPad Pro. Draw a masterpiece, take notes, or knock out a business plan. These versatile accessories are designed to take your work and creativity to the next level.
Apple Pencil.
With the power of Apple Pencil (2nd generation), iPad Pro transforms into an immersive drawing canvas and the world’s best note‑taking device. It sets the standard for how drawing, marking up documents, and even filling in text fields should feel — intuitive, precise, and magical.
Learn more about Apple Pencil
Procreate
A new dimension of Apple Pencil.
Apple Pencil hover shows you exactly where your Apple Pencil will touch down on your display. So you can write, sketch, and illustrate with even greater precision. Watch apps and widgets expand on the Home Screen as you move over them. Preview your mark before you make it. See how your watercolors mix before you paint. Apple Pencil hover makes everything you do with Apple Pencil even more effortless.
When Apple Pencil hovers over the display, electromagnetic signals emitted from the tip are detected by the screen up to 12 mm away. M2 instantly interprets those signals and determines the position of Apple Pencil in three dimensions.
12 mm
Magic Keyboard.
Magic Keyboard features a responsive typing experience and a built&#x;in trackpad that gives you many more ways to work with iPadOS. So you can write your novel, crank out a term paper, or rip through your inbox. And with backlit keys, you can get things done in any light.
Learn more about keyboards for iPad
Swift Playgrounds
Amazing apps for every workflow.
Environment
Apple is carbon neutral. And by , all of our products will be too. We’re committed to one day sourcing % recycled and renewable materials across our products and packaging, all with clean energy and no carbon footprint.
Apple and the Environment
Privacy
Like every Apple product, iPad was designed with your privacy and security in mind. It’s not always easy. But that’s the kind of innovation we believe in.
Learn more about our approach to privacy
Accessibility
Technology is most powerful when everyone can use it. That’s why iPad comes with accessibility features that support vision, hearing, mobility, and learning needs.
Explore all accessibility features
Accessories
Explore keyboards, cases, covers, Apple Pencil, AirPods, and more.
Shop iPad accessories
Trade in your current iPad and get credit toward a new one.
With Apple Trade In, just give us your eligible iPad and get credit for a new one. It’s good for you and the planet.
Find your trade-in value
Which iPad is right for you?
The ultimate iPad experience with the most advanced technology.
″ or 11″
Liquid Retina XDR display or Liquid Retina display
12MP Ultra Wide front camera
USB&#x;C connector with support for Thunderbolt / USB 4
Supports Apple Pencil (2nd generation)
Supports Apple Pencil (USB&#x;C)
Serious performance in a thin and light design.
″
12MP Ultra Wide front camera
Supports Apple Pencil (2nd generation)
Supports Apple Pencil (USB&#x;C)
The colorful, all&#x;screen iPad for the things you do every day.
″
Landscape 12MP Ultra Wide front camera
Supports Apple Pencil (USB&#x;C)
Supports Apple Pencil (1st generation)
Supports Magic Keyboard Folio
All the essentials in the most affordable iPad.
″
12MP Ultra Wide front camera
Supports Apple Pencil (1st generation)
The full iPad experience designed to fit in one hand.
″
12MP Ultra Wide front camera
Supports Apple Pencil (2nd generation)
Supports Apple Pencil (USB&#x;C)
Supports Bluetooth keyboards
Signals & Slots
Introduction
In GUI programming, when we change one widget, we often want another widget to be notified. More generally, we want objects of any kind to be able to communicate with one another. For example, if a user clicks a Close button, we probably want the window's close() function to be called.
Other toolkits achieve this kind of communication using callbacks. A callback is a pointer to a function, so if you want a processing function to notify you about some event you pass a pointer to another function (the callback) to the processing function. The processing function then calls the callback when appropriate. While successful frameworks using this method do exist, callbacks can be unintuitive and may suffer from problems in ensuring the type-correctness of callback arguments.
Signals and Slots
In Qt, we have an alternative to the callback technique: We use signals and slots. A signal is emitted when a particular event occurs. Qt's widgets have many predefined signals, but we can always subclass widgets to add our own signals to them. A slot is a function that is called in response to a particular signal. Qt's widgets have many pre-defined slots, but it is common practice to subclass widgets and add your own slots so that you can handle the signals that you are interested in.
The signals and slots mechanism is type safe: The signature of a signal must match the signature of the receiving slot. (In fact a slot may have a shorter signature than the signal it receives because it can ignore extra arguments.) Since the signatures are compatible, the compiler can help us detect type mismatches when using the function pointer-based syntax. The string-based SIGNAL and SLOT syntax will detect type mismatches at runtime. Signals and slots are loosely coupled: A class which emits a signal neither knows nor cares which slots receive the signal. Qt's signals and slots mechanism ensures that if you connect a signal to a slot, the slot will be called with the signal's parameters at the right time. Signals and slots can take any number of arguments of any type. They are completely type safe.
All classes that inherit from QObject or one of its subclasses (e.g., QWidget) can contain signals and slots. Signals are emitted by objects when they change their state in a way that may be interesting to other objects. This is all the object does to communicate. It does not know or care whether anything is receiving the signals it emits. This is true information encapsulation, and ensures that the object can be used as a software component.
Slots can be used for receiving signals, but they are also normal member functions. Just as an object does not know if anything receives its signals, a slot does not know if it has any signals connected to it. This ensures that truly independent components can be created with Qt.
You can connect as many signals as you want to a single slot, and a signal can be connected to as many slots as you need. It is even possible to connect a signal directly to another signal. (This will emit the second signal immediately whenever the first is emitted.)
Together, signals and slots make up a powerful component programming mechanism.
Signals
Signals are emitted by an object when its internal state has changed in some way that might be interesting to the object's client or owner. Signals are public access functions and can be emitted from anywhere, but we recommend to only emit them from the class that defines the signal and its subclasses.
When a signal is emitted, the slots connected to it are usually executed immediately, just like a normal function call. When this happens, the signals and slots mechanism is totally independent of any GUI event loop. Execution of the code following the statement will occur once all slots have returned. The situation is slightly different when using queued connections; in such a case, the code following the keyword will continue immediately, and the slots will be executed later.
If several slots are connected to one signal, the slots will be executed one after the other, in the order they have been connected, when the signal is emitted.
Signals are automatically generated by the moc and must not be implemented in the file.
A note about arguments: Our experience shows that signals and slots are more reusable if they do not use special types. If QScrollBar::valueChanged() were to use a special type such as the hypothetical QScrollBar::Range, it could only be connected to slots designed specifically for QScrollBar. Connecting different input widgets together would be impossible.
Slots
A slot is called when a signal connected to it is emitted. Slots are normal C++ functions and can be called normally; their only special feature is that signals can be connected to them.
Since slots are normal member functions, they follow the normal C++ rules when called directly. However, as slots, they can be invoked by any component, regardless of its access level, via a signal-slot connection. This means that a signal emitted from an instance of an arbitrary class can cause a private slot to be invoked in an instance of an unrelated class.
You can also define slots to be virtual, which we have found quite useful in practice.
Compared to callbacks, signals and slots are slightly slower because of the increased flexibility they provide, although the difference for real applications is insignificant. In general, emitting a signal that is connected to some slots, is approximately ten times slower than calling the receivers directly, with non-virtual function calls. This is the overhead required to locate the connection object, to safely iterate over all connections (i.e. checking that subsequent receivers have not been destroyed during the emission), and to marshall any parameters in a generic fashion. While ten non-virtual function calls may sound like a lot, it's much less overhead than any or operation, for example. As soon as you perform a string, vector or list operation that behind the scene requires or , the signals and slots overhead is only responsible for a very small proportion of the complete function call costs. The same is true whenever you do a system call in a slot; or indirectly call more than ten functions. The simplicity and flexibility of the signals and slots mechanism is well worth the overhead, which your users won't even notice.
Note that other libraries that define variables called or may cause compiler warnings and errors when compiled alongside a Qt-based application. To solve this problem, the offending preprocessor symbol.
A Small Example
A minimal C++ class declaration might read:
class Counter { public: Counter() { m_value =0; } int value() const { return m_value; } void setValue(int value); private: int m_value; };
The QObject-based version has the same internal state, and provides public methods to access the state, but in addition it has support for component programming using signals and slots. This class can tell the outside world that its state has changed by emitting a signal, , and it has a slot which other objects can send signals to.
All classes that contain signals or slots must mention Q_OBJECT at the top of their declaration. They must also derive (directly or indirectly) from QObject.
Slots are implemented by the application programmer. Here is a possible implementation of the slot:
Calling makes emit a signal, which will receive in its slot, i.e. is called. Then emits the same signal, but since no slot has been connected to 's signal, the signal is ignored.
Note that the function sets the value and emits the signal only if . This prevents infinite looping in the case of cyclic connections (e.g., if were connected to ).
By default, for every connection you make, a signal is emitted; two signals are emitted for duplicate connections. You can break all of these connections with a single disconnect() call. If you pass the Qt::UniqueConnectiontype, the connection will only be made if it is not a duplicate. If there is already a duplicate (exact same signal to the exact same slot on the same objects), the connection will fail and connect will return .
This example illustrates that objects can work together without needing to know any information about each other. To enable this, the objects only need to be connected together, and this can be achieved with some simple QObject::connect() function calls, or with uic's automatic connections feature.
A Real Example
The following is an example of the header of a simple widget class without member functions. The purpose is to show how you can utilize signals and slots in your own applications.
inherits QObject, which has most of the signal-slot knowledge, via QFrame and QWidget. It is somewhat similar to the built-in QLCDNumber widget.
The Q_OBJECT macro is expanded by the preprocessor to declare several member functions that are implemented by the ; if you get compiler errors along the lines of "undefined reference to vtable for ", you have probably forgotten to run the moc or to include the moc output in the link command.
After the class constructor and members, we declare the class . The class emits a signal, , when it is asked to show an impossible value.
If you don't care about overflow, or you know that overflow cannot occur, you can ignore the signal, i.e. don't connect it to any slot.
If on the other hand you want to call two different error functions when the number overflows, simply connect the signal to two different slots. Qt will call both (in the order they were connected).
A slot is a receiving function used to get information about state changes in other widgets. uses it, as the code above indicates, to set the displayed number. Since is part of the class's interface with the rest of the program, the slot is public.
Several of the example programs connect the valueChanged() signal of a QScrollBar to the slot, so the LCD number continuously shows the value of the scroll bar.
Note that is overloaded; Qt will select the appropriate version when you connect a signal to the slot. With callbacks, you'd have to find five different names and keep track of the types yourself.
Signals And Slots With Default Arguments
The signatures of signals and slots may contain arguments, and the arguments can have default values. Consider QObject::destroyed():
void destroyed(QObject*= nullptr);
When a QObject is deleted, it emits this QObject::destroyed() signal. We want to catch this signal, wherever we might have a dangling reference to the deleted QObject, so we can clean it up. A suitable slot signature might be:
void objectDestroyed(QObject* obj = nullptr);
To connect the signal to the slot, we use QObject::connect(). There are several ways to connect signal and slots. The first is to use function pointers:
There are several advantages to using QObject::connect() with function pointers. First, it allows the compiler to check that the signal's arguments are compatible with the slot's arguments. Arguments can also be implicitly converted by the compiler, if needed.
You can also connect to functors or C++11 lambdas:
In both these cases, we provide this as context in the call to connect(). The context object provides information about in which thread the receiver should be executed. This is important, as providing the context ensures that the receiver is executed in the context thread.
The lambda will be disconnected when the sender or context is destroyed. You should take care that any objects used inside the functor are still alive when the signal is emitted.
The other way to connect a signal to a slot is to use QObject::connect() and the and macros. The rule about whether to include arguments or not in the and macros, if the arguments have default values, is that the signature passed to the macro must not have fewer arguments than the signature passed to the macro.
because the slot will be expecting a QObject that the signal will not send. This connection will report a runtime error.
Note that signal and slot arguments are not checked by the compiler when using this QObject::connect() overload.
Advanced Signals and Slots Usage
For cases where you may require information on the sender of the signal, Qt provides the QObject::sender() function, which returns a pointer to the object that sent the signal.
Lambda expressions are a convenient way to pass custom arguments to a slot:
It is possible to use Qt with a 3rd party signal/slot mechanism. You can even use both mechanisms in the same project. To do that, write the following into your CMake project file:
In a qmake project (.pro) file, you need to write:
It tells Qt not to define the moc keywords , , and , because these names will be used by a 3rd party library, e.g. Boost. Then to continue using Qt signals and slots with the flag, simply replace all uses of the Qt moc keywords in your sources with the corresponding Qt macros Q_SIGNALS (or Q_SIGNAL), Q_SLOTS (or Q_SLOT), and Q_EMIT.
Signals and slots in Qt-based libraries
The public API of Qt-based libraries should use the keywords and instead of and . Otherwise it is hard to use such a library in a project that defines .
To enforce this restriction, the library creator may set the preprocessor define when building the library.
This define excludes signals and slots without affecting whether other Qt-specific keywords can be used in the library implementation.
See also QLCDNumber, QObject::connect(), Meta-Object System, and Qt's Property System.
Markers
Introduction
A marker identifies a location on a map. By default, a marker uses a standard image. Markers can display custom images, in which case they are usually referred to as "icons." Markers and icons are objects of type . You can set a custom icon within the marker's constructor, or by calling on the marker. See more about customizing the marker image.
Broadly speaking, markers are a type of overlay. For information on other types of overlay, see Drawing on the map.
Markers are designed to be interactive. For example, by default they receive events, so you can add an event listener to bring up an info window displaying custom information. You can allow users to move a marker on the map by setting the marker's property to . For more information about draggable markers, see below.
Add a marker
The constructor takes a single object literal, specifying the initial properties of the marker.
The following fields are particularly important and commonly set when constructing a marker:
(required) specifies a identifying the initial location of the marker. One way of retrieving a is by using the Geocoding service.
(optional) specifies the on which to place the marker. If you do not specify the map on construction of the marker, the marker is created but is not attached to (or displayed on) the map. You may add the marker later by calling the marker's method.
The following example adds a simple marker to a map at Uluru, in the center of Australia: