API Coverage

This document provides a reference of the pygame-ce API and implementation status in ipygame.

Legend:

✅ Implemented - Function is fully implemented and tested
❌ Not Implemented - Function is missing or stub only
🚫 Not Applicable - Cannot be implemented in Jupyter environment

Last Updated: February 11, 2026

Core Module (pygame)
pygame.display
pygame.Surface
pygame.draw
pygame.event
pygame.key
pygame.mouse
pygame.time
pygame.font
pygame.image
pygame.transform
pygame.sprite
pygame.Rect / FRect
pygame.Color
pygame.math
pygame.mask
pygame.gfxdraw
pygame.surfarray
pygame.pixelcopy
pygame.mixer
pygame.mixer.music
pygame.joystick
pygame.camera
pygame.freetype
pygame.cursors
pygame.midi
pygame.sndarray
pygame.scrap
pygame.Window
pygame.geometry
pygame.system
Summary Statistics

Core Module (pygame)

Function	Status	Notes
`pygame.init()`	✅	Returns (6, 0) tuple
`pygame.quit()`	✅	Cleans up backend state
`pygame.get_init()`	✅	Returns initialization status
`pygame.error`	✅	Exception class compatible with pygame
`pygame.get_error()`	❌	SDL error retrieval not applicable
`pygame.set_error()`	❌	SDL error setting not applicable
`pygame.get_sdl_version()`	❌	No SDL in ipygame
`pygame.get_sdl_byteorder()`	❌	No SDL in ipygame
`pygame.register_quit()`	❌	Quit callback registration
`pygame.encode_string()`	❌	String encoding utility
`pygame.encode_file_path()`	❌	Path encoding utility
`error()`	❌

pygame.display

Function	Status	Notes
`display.init()`	✅	Initializes display module
`display.quit()`	✅	Uninitializes display, clears canvas
`display.get_init()`	✅	Returns init status
`display.set_mode(size, flags, depth, display, vsync)`	✅	Creates ipycanvas Canvas widget
`display.get_surface()`	✅	Returns current display Surface
`display.flip()`	✅	Updates entire display to canvas
`display.update(rectangle)`	✅	Updates display (currently full screen)
`display.get_driver()`	❌	Returns “ipycanvas”
`display.Info()`	❌	Returns basic info object
`display.get_wm_info()`	❌	Window manager info not applicable
`display.get_desktop_sizes()`	❌	Multi-monitor support N/A
`display.list_modes(depth, flags, display)`	❌	Mode enumeration N/A
`display.mode_ok(size, flags, depth)`	❌	Mode validation N/A
`display.gl_get_attribute(flag)`	❌	OpenGL not supported
`display.gl_set_attribute(flag, value)`	❌	OpenGL not supported
`display.get_active()`	❌	Window focus state
`display.iconify()`	❌	Stub (no effect in Jupyter)
`display.toggle_fullscreen()`	❌	Stub (no effect in Jupyter)
`display.set_gamma(red, green, blue)`	❌	Gamma correction N/A
`display.set_gamma_ramp(red, green, blue)`	❌	Gamma ramp N/A
`display.set_icon(surface)`	❌	Stored but not displayed
`display.set_caption(title, icontitle)`	✅	Stores caption string
`display.get_caption()`	✅	Returns caption tuple
`display.set_palette(palette)`	❌	Palette mode not used
`display.get_num_displays()`	❌	Multi-display N/A
`display.get_window_size()`	✅	Returns canvas dimensions
`display.get_allow_screensaver()`	❌	Screensaver control N/A
`display.set_allow_screensaver(bool)`	❌	Screensaver control N/A
`display.is_fullscreen()`	❌	Fullscreen state N/A

pygame.Surface

Method	Status	Notes
`Surface(size, flags, surface)`	✅	Creates surface matching another
`blit(source, dest, area, special_flags)`	✅	Blits with alpha blending
`blits(sequence, doreturn)`	✅	Multiple blits
`fblits(sequence, doreturn)`	❌	Fast blits without return
`convert(surface)`	✅	Converts format (returns self, already RGBA)
`convert_alpha(surface)`	✅	Converts to alpha format
`copy()`	✅	Creates surface copy
`fill(color, rect, special_flags)`	✅	Fills with solid color
`scroll(dx, dy)`	❌	Surface scrolling
`set_colorkey(color, flags)`	✅	Sets transparent color
`get_colorkey()`	✅	Returns colorkey
`set_alpha(value, flags)`	✅	Sets surface alpha
`get_alpha()`	✅	Returns surface alpha
`lock()`	✅	Locks surface (reference counting)
`unlock()`	✅	Unlocks surface
`mustlock()`	✅	Always returns False
`get_locked()`	✅	Returns lock status
`get_locks()`	✅	Returns lock tuple
`get_at(pos)`	✅	Gets pixel Color
`set_at(pos, color)`	✅	Sets pixel color
`get_at_mapped(pos)`	❌	Returns RGBA tuple as int
`get_palette()`	❌	No palette mode
`get_palette_at(index)`	❌	No palette mode
`set_palette(palette)`	❌	No palette mode
`set_palette_at(index, color)`	❌	No palette mode
`map_rgb(color)`	✅	Maps color to pixel value
`unmap_rgb(mapped_int)`	✅	Unmaps pixel to Color
`set_clip(rect)`	✅	Sets clipping rectangle
`get_clip()`	✅	Gets clipping rectangle
`subsurface(rect)`	✅	Creates subsurface view
`get_parent()`	✅	Returns parent surface
`get_abs_parent()`	✅	Returns root parent
`get_offset()`	✅	Returns subsurface offset
`get_abs_offset()`	✅	Returns absolute offset
`get_size()`	✅	Returns (width, height)
`get_width()`	✅	Returns width
`get_height()`	✅	Returns height
`get_rect(**kwargs)`	✅	Returns Rect with size
`get_frect(**kwargs)`	✅	Returns FRect with size
`get_bitsize()`	✅	Returns 32
`get_bytesize()`	✅	Returns 4
`get_flags()`	✅	Returns surface flags
`get_pitch()`	✅	Returns bytes per row
`get_masks()`	✅	Returns RGBA masks
`get_shifts()`	✅	Returns RGBA shifts
`get_losses()`	✅	Returns (0,0,0,0)
`get_bounding_rect(min_alpha)`	✅	Returns bounding rect of non-transparent pixels
`get_view(kind)`	❌	Buffer view access
`get_buffer()`	❌	Raw buffer access
`_pixels_address`	❌	Memory address (not applicable)
`premul_alpha()`	❌	Premultiplied alpha conversion
`blit_array(array, dest)`	❌	Array blitting
`Surface.blit()`	❌
`Surface.blits()`	❌
`Surface.convert()`	❌
`Surface.convert_alpha()`	❌
`Surface.copy()`	❌
`Surface.fblits()`	❌
`Surface.fill()`	❌
`Surface.get_alpha()`	❌
`Surface.get_at()`	❌
`Surface.get_at_mapped()`	❌
`Surface.get_bitsize()`	❌
`Surface.get_bounding_rect()`	❌
`Surface.get_buffer()`	❌
`Surface.get_bytesize()`	❌
`Surface.get_clip()`	❌
`Surface.get_colorkey()`	❌
`Surface.get_flags()`	❌
`Surface.get_frect()`	❌
`Surface.get_height()`	❌
`Surface.get_locked()`	❌
`Surface.get_locks()`	❌
`Surface.get_losses()`	❌
`Surface.get_masks()`	❌
`Surface.get_pitch()`	❌
`Surface.get_rect()`	❌
`Surface.get_shifts()`	❌
`Surface.get_size()`	❌
`Surface.get_view()`	❌
`Surface.get_width()`	❌
`Surface.height()`	❌
`Surface.lock()`	❌
`Surface.map_rgb()`	❌
`Surface.mustlock()`	❌
`Surface.premul_alpha()`	❌
`Surface.premul_alpha_ip()`	❌
`Surface.scroll()`	❌
`Surface.set_alpha()`	❌
`Surface.set_at()`	❌
`Surface.set_clip()`	❌
`Surface.set_colorkey()`	❌
`Surface.size()`	❌
`Surface.subsurface()`	❌
`Surface.unlock()`	❌
`Surface.unmap_rgb()`	❌
`Surface.width()`	❌

pygame.draw

Function	Status	Notes
`draw.rect(surface, color, rect, width, border_radius, ...)`	✅	Draws rectangle with border radius support
`draw.polygon(surface, color, points, width)`	✅	Draws polygon
`draw.circle(surface, color, center, radius, width, ...)`	✅	Draws circle
`draw.ellipse(surface, color, rect, width)`	✅	Draws ellipse
`draw.arc(surface, color, rect, start_angle, stop_angle, width)`	✅	Draws arc
`draw.line(surface, color, start_pos, end_pos, width)`	✅	Draws line
`draw.lines(surface, color, closed, points, width)`	✅	Draws connected lines
`draw.aaline(surface, color, start_pos, end_pos, blend)`	✅	Anti-aliased line
`draw.aalines(surface, color, closed, points, blend)`	✅	Anti-aliased lines

pygame.event

Function	Status	Notes
`Event(type, dict, **kwargs)`	✅	Event object with type and attributes
`event.pump()`	✅	No-op (events arrive via callbacks)
`event.get(eventtype, pump, exclude)`	✅	Get and remove events
`event.poll()`	✅	Get single event or NOEVENT
`event.wait(timeout)`	✅	Wait for event (polls in Jupyter)
`event.peek(eventtype, pump)`	✅	Check for events without removing
`event.clear(eventtype, pump)`	✅	Remove events from queue
`event.event_name(type)`	✅	Get event name string
`event.set_blocked(type)`	✅	Block event types
`event.set_allowed(type)`	✅	Allow event types
`event.get_blocked(type)`	✅	Check if event type blocked
`event.set_grab(grab)`	✅	Set input grab state
`event.get_grab()`	✅	Get input grab state
`event.post(event)`	✅	Post event to queue
`event.custom_type()`	✅	Get unique event type ID
`event.set_keyboard_grab(grab)`	❌	Keyboard grab control
`event.get_keyboard_grab()`	❌	Get keyboard grab state

pygame.key

Function	Status	Notes
`key.get_focused()`	✅	Returns True (canvas focus assumed)
`key.get_pressed()`	✅	Returns ScancodeWrapper of key states
`key.get_just_pressed()`	✅	Returns keys pressed this frame
`key.get_just_released()`	✅	Returns keys released this frame
`key.get_mods()`	✅	Returns modifier key bitmask
`key.set_mods(mods)`	✅	Sets modifier state
`key.set_repeat(delay, interval)`	✅	Sets key repeat
`key.get_repeat()`	✅	Gets key repeat settings
`key.name(key)`	✅	Get key name string
`key.key_code(name)`	✅	Get key constant from name
`key.start_text_input()`	✅	Enable text input (stored state)
`key.stop_text_input()`	✅	Disable text input
`key.set_text_input_rect(rect)`	❌	Stored but no IME positioning
`ScancodeWrapper()`	❌

pygame.mouse

Function	Status	Notes
`mouse.get_pressed(num_buttons, desktop)`	✅	Returns button states
`mouse.get_just_pressed()`	✅	Buttons pressed this frame
`mouse.get_just_released()`	✅	Buttons released this frame
`mouse.get_pos()`	✅	Returns mouse position
`mouse.get_rel()`	✅	Returns relative movement
`mouse.set_pos(pos)`	❌	Stores position (can’t move cursor in browser)
`mouse.set_visible(bool)`	❌	Stores state (limited browser control)
`mouse.get_visible()`	✅	Returns visibility state
`mouse.get_focused()`	✅	Returns True (assumes focus)
`mouse.set_cursor(cursor)`	❌	Stored but limited browser control
`mouse.get_cursor()`	✅	Returns current cursor
`mouse.set_relative_mode(bool)`	❌	Stores state (limited in browser)
`mouse.get_relative_mode()`	✅	Returns relative mode state
`Cursor()`	❌

pygame.time

Function	Status	Notes
`time.get_ticks()`	✅	Milliseconds since init()
`time.wait(milliseconds)`	✅	Pause using time.sleep()
`time.delay(milliseconds)`	✅	Accurate delay (same as wait in ipygame)
`time.set_timer(event, millis, loops)`	✅	Post events periodically using threading
`Clock()`	✅	Clock class
`Clock.tick(framerate)`	✅	Update clock with frame limiting
`Clock.tick_busy_loop(framerate)`	✅	Accurate tick with busy wait
`Clock.get_time()`	✅	Time of previous tick
`Clock.get_rawtime()`	✅	Raw time without delay
`Clock.get_fps()`	✅	Calculate framerate

pygame.font

Function	Status	Notes
`font.init()`	✅	Initialize font module
`font.quit()`	✅	Uninitialize font module
`font.get_init()`	✅	Get init status
`font.get_default_font()`	✅	Returns “freesansbold.ttf”
`font.get_fonts()`	✅	List system fonts
`font.match_font(name, bold, italic)`	✅	Find system font file
`font.SysFont(name, size, bold, italic)`	✅	Create system font
`Font(filename, size)`	✅	Create Font from file
`Font.render(text, antialias, color, background)`	✅	Render text to surface using Pillow
`Font.size(text)`	✅	Get rendered text dimensions
`Font.set_underline(bool)`	✅	Enable/disable underline
`Font.get_underline()`	✅	Get underline state
`Font.set_bold(bool)`	✅	Enable/disable bold
`Font.get_bold()`	✅	Get bold state
`Font.set_italic(bool)`	✅	Enable/disable italic
`Font.get_italic()`	✅	Get italic state
`Font.metrics(text)`	❌	Character metrics
`Font.get_linesize()`	❌	Line spacing
`Font.get_height()`	❌	Font height
`Font.get_ascent()`	❌	Ascent metric
`Font.get_descent()`	❌	Descent metric
`font.get_sdl_ttf_version()`	❌	Returns (0,0,0)

pygame.image

Function	Status	Notes
`image.load(file, namehint)`	✅	Load image using Pillow
`image.save(surface, file, namehint)`	✅	Save image using Pillow
`image.get_extended()`	❌	Returns True (Pillow supports extended formats)
`image.tostring(surface, format, flipped)`	✅	Surface to bytes (deprecated)
`image.tobytes(surface, format, flipped)`	✅	Surface to bytes
`image.fromstring(bytes, size, format, flipped)`	✅	Bytes to surface (deprecated)
`image.frombytes(bytes, size, format, flipped)`	✅	Bytes to surface
`image.frombuffer(buffer, size, format)`	✅	Buffer to surface
`image.load_basic(file)`	✅	Load basic formats
`image.load_extended(file, namehint)`	✅	Load extended formats
`image.save_extended(surface, file, namehint)`	✅	Save extended formats
`image.load_sized_svg(file, size)`	❌	Stub raises NotImplementedError
`image.get_sdl_image_version()`	❌

pygame.transform

Function	Status	Notes
`transform.flip(surface, flip_x, flip_y)`	✅	Flip surface
`transform.scale(surface, size, dest_surface)`	✅	Scale using Pillow
`transform.scale_by(surface, factor, dest_surface)`	✅	Scale by factor
`transform.rotate(surface, angle)`	✅	Rotate using Pillow
`transform.rotozoom(surface, angle, scale)`	✅	Combined rotate and zoom
`transform.scale2x(surface, dest_surface)`	✅	2x scale (uses Pillow)
`transform.smoothscale(surface, size, dest_surface)`	✅	Smooth scale using Pillow
`transform.smoothscale_by(surface, factor, dest_surface)`	✅	Smooth scale by factor
`transform.get_smoothscale_backend()`	✅	Returns “GENERIC”
`transform.set_smoothscale_backend(backend)`	✅	No-op (always Pillow)
`transform.chop(surface, rect)`	✅	Extract region
`transform.laplacian(surface, dest_surface)`	✅	Edge detection filter
`transform.average_surfaces(surfaces, dest_surface, palette_colors)`	✅	Average multiple surfaces
`transform.average_color(surface, rect, consider_alpha)`	✅	Average color in region
`transform.threshold(...)`	✅	Color threshold operation
`transform.grayscale(surface, dest_surface)`	✅	Convert to grayscale
`transform.invert(surface, dest_surface)`	✅	Invert colors
`transform.box_blur(surface, radius, repeat_edge_pixels, dest_surface)`	✅	Box blur filter
`transform.gaussian_blur(surface, radius, repeat_edge_pixels, dest_surface)`	✅	Gaussian blur
`transform.hsl(surface, hue_adjust, sat_adjust, light_adjust)`	✅	HSL color adjustment
`transform.pixelate(surface, size, dest_surface)`	✅	Pixelate effect
`transform.solid_overlay(surface, color, dest_surface)`	✅	Solid color overlay

pygame.sprite

Class/Function	Status	Notes
`Sprite(*groups)`	✅	Basic sprite class
`Sprite.image`	✅	Surface attribute
`Sprite.rect`	✅	Rect attribute
`Sprite.add(*groups)`	✅	Add to groups
`Sprite.remove(*groups)`	✅	Remove from groups
`Sprite.kill()`	✅	Remove from all groups
`Sprite.alive()`	✅	Check if in any group
`Sprite.groups()`	✅	List of containing groups
`Sprite.update(args, *kwargs)`	✅	Update method (override)
`DirtySprite`	❌	Dirty rect optimization
`Group(*sprites)`	✅	Basic sprite group
`Group.sprites()`	✅	List of sprites
`Group.copy()`	✅	Copy group
`Group.add(*sprites)`	✅	Add sprites
`Group.remove(*sprites)`	✅	Remove sprites
`Group.has(*sprites)`	✅	Check membership
`Group.update(args, *kwargs)`	✅	Update all sprites
`Group.draw(surface)`	✅	Draw all sprites
`Group.clear(surface, bgd)`	✅	Clear sprites
`Group.empty()`	✅	Remove all sprites
`GroupSingle(sprite)`	✅	Group holding single sprite
`RenderPlain`	❌	Alias for Group
`RenderClear`	❌	Render with clear
`RenderUpdates`	✅	Group tracking dirty rects
`OrderedUpdates`	✅	Ordered sprite group
`LayeredUpdates`	✅	Layered sprite group
`LayeredDirty`	❌	Layered with dirty rects
`spritecollide(sprite, group, dokill, collided)`	✅	Sprite-group collision
`collide_rect(left, right)`	✅	Rectangle collision
`collide_rect_ratio(ratio)`	❌	Scaled rect collision
`collide_circle(left, right)`	✅	Circle collision
`collide_circle_ratio(ratio)`	❌	Scaled circle collision
`collide_mask(left, right)`	✅	Mask collision
`groupcollide(group1, group2, dokill1, dokill2, collided)`	✅	Group-group collision
`spritecollideany(sprite, group, collided)`	✅	Check any collision
`sprite.groupcollide()`	❌
`sprite.spritecollide()`	❌
`sprite.spritecollideany()`	❌

pygame.Rect / FRect

Method/Property	Status	Notes
`Rect(left, top, width, height)`	✅	Integer rect
`FRect(left, top, width, height)`	✅	Float rect
`x, y, w, h, width, height`	✅	Basic properties
`top, left, bottom, right`	✅	Edge properties
`topleft, topright, bottomleft, bottomright`	✅	Corner properties
`midtop, midleft, midbottom, midright`	✅	Mid-edge properties
`center, centerx, centery`	✅	Center properties
`size`	✅	(w, h) tuple
`copy()`	✅	Copy rect
`move(x, y)`	✅	Move rect
`move_ip(x, y)`	✅	Move in-place
`inflate(x, y)`	✅	Grow/shrink rect
`inflate_ip(x, y)`	✅	Grow/shrink in-place
`update(left, top, width, height)`	✅	Update values
`clamp(rect)`	✅	Clamp inside rect
`clamp_ip(rect)`	✅	Clamp in-place
`clip(rect)`	✅	Intersection
`clipline(x1, y1, x2, y2)`	✅	Clip line to rect
`union(rect)`	✅	Bounding union
`union_ip(rect)`	✅	Union in-place
`unionall(rect_list)`	✅	Union of multiple rects
`unionall_ip(rect_list)`	✅	Union all in-place
`fit(rect)`	✅	Fit inside rect
`normalize()`	✅	Ensure positive w, h
`contains(rect)`	✅	Check containment
`collidepoint(x, y)`	✅	Point collision
`colliderect(rect)`	✅	Rect collision
`collidelist(list)`	✅	Test against list
`collidelistall(list)`	✅	All collisions in list
`collidedict(dict)`	✅	Dict collision test
`collidedictall(dict)`	✅	All dict collisions
`collideobjectsall(objects)`	✅	Collision with objects
`collideobjects(objects)`	✅	First collision with objects
`FRect.bottom()`	❌
`FRect.bottomleft()`	❌
`FRect.bottomright()`	❌
`FRect.center()`	❌
`FRect.centerx()`	❌
`FRect.centery()`	❌
`FRect.clamp()`	❌
`FRect.clamp_ip()`	❌
`FRect.clip()`	❌
`FRect.collidelist()`	❌
`FRect.collidelistall()`	❌
`FRect.collidepoint()`	❌
`FRect.colliderect()`	❌
`FRect.contains()`	❌
`FRect.copy()`	❌
`FRect.fit()`	❌
`FRect.h()`	❌
`FRect.height()`	❌
`FRect.inflate()`	❌
`FRect.inflate_ip()`	❌
`FRect.left()`	❌
`FRect.midbottom()`	❌
`FRect.midleft()`	❌
`FRect.midright()`	❌
`FRect.midtop()`	❌
`FRect.move()`	❌
`FRect.move_ip()`	❌
`FRect.move_to()`	❌
`FRect.normalize()`	❌
`FRect.right()`	❌
`FRect.scale_by()`	❌
`FRect.scale_by_ip()`	❌
`FRect.size()`	❌
`FRect.top()`	❌
`FRect.topleft()`	❌
`FRect.topright()`	❌
`FRect.union()`	❌
`FRect.union_ip()`	❌
`FRect.unionall()`	❌
`FRect.unionall_ip()`	❌
`FRect.update()`	❌
`FRect.w()`	❌
`FRect.width()`	❌
`FRect.x()`	❌
`FRect.y()`	❌
`Rect.bottom()`	❌
`Rect.bottomleft()`	❌
`Rect.bottomright()`	❌
`Rect.center()`	❌
`Rect.centerx()`	❌
`Rect.centery()`	❌
`Rect.clamp()`	❌
`Rect.clamp_ip()`	❌
`Rect.clip()`	❌
`Rect.clipline()`	❌
`Rect.collidedict()`	❌
`Rect.collidedictall()`	❌
`Rect.collidelist()`	❌
`Rect.collidelistall()`	❌
`Rect.collideobjects()`	❌
`Rect.collideobjectsall()`	❌
`Rect.collidepoint()`	❌
`Rect.colliderect()`	❌
`Rect.contains()`	❌
`Rect.copy()`	❌
`Rect.fit()`	❌
`Rect.h()`	❌
`Rect.height()`	❌
`Rect.inflate()`	❌
`Rect.inflate_ip()`	❌
`Rect.left()`	❌
`Rect.midbottom()`	❌
`Rect.midleft()`	❌
`Rect.midright()`	❌
`Rect.midtop()`	❌
`Rect.move()`	❌
`Rect.move_ip()`	❌
`Rect.move_to()`	❌
`Rect.normalize()`	❌
`Rect.right()`	❌
`Rect.scale_by()`	❌
`Rect.scale_by_ip()`	❌
`Rect.size()`	❌
`Rect.top()`	❌
`Rect.topleft()`	❌
`Rect.topright()`	❌
`Rect.union()`	❌
`Rect.union_ip()`	❌
`Rect.unionall()`	❌
`Rect.unionall_ip()`	❌
`Rect.update()`	❌
`Rect.w()`	❌
`Rect.width()`	❌
`Rect.x()`	❌
`Rect.y()`	❌

pygame.Color

Method/Property	Status	Notes
`Color(mapped_int)`	✅	Packed integer
`r, g, b, a`	✅	RGBA properties
`hsva`	✅	HSV+alpha tuple
`hsla`	✅	HSL+alpha tuple
`cmy`	✅	CMY tuple
`i1i2i3`	✅	I1I2I3 color space
`normalize()`	✅	Normalized RGBA
`correct_gamma(gamma)`	✅	Gamma correction
`set_length(len)`	✅	Set tuple length
`grayscale()`	✅	Convert to grayscale
`lerp(color, t)`	✅	Linear interpolation
`premul_alpha()`	✅	Premultiply alpha
`update(r, g, b, a)`	✅	Update values
`Arithmetic operators`	✅	+, -, , //, %, *
`Comparison operators`	✅	==, !=
`Indexing/iteration`	✅	color[i], for c in color
`Color.a()`	❌
`Color.b()`	❌
`Color.cmy()`	❌
`Color.correct_gamma()`	❌
`Color.from_cmy()`	❌
`Color.from_hex()`	❌
`Color.from_hsla()`	❌
`Color.from_hsva()`	❌
`Color.from_i1i2i3()`	❌
`Color.from_normalized()`	❌
`Color.g()`	❌
`Color.grayscale()`	❌
`Color.hex()`	❌
`Color.hsla()`	❌
`Color.hsva()`	❌
`Color.i1i2i3()`	❌
`Color.lerp()`	❌
`Color.normalize()`	❌
`Color.normalized()`	❌
`Color.premul_alpha()`	❌
`Color.r()`	❌
`Color.update()`	❌

pygame.math

Class/Function	Status	Notes
`Vector2(x, y)`	✅	2D vector
`Vector3(x, y, z)`	✅	3D vector
`Vector2.x, Vector2.y`	✅	Components
`Vector3.x, Vector3.y, Vector3.z`	✅	Components
`Arithmetic operators`	✅	+, -, *, /, //, %
`dot(other)`	✅	Dot product
`cross(other)`	✅	Cross product (Vector3)
`magnitude()`	✅	Vector length
`magnitude_squared()`	✅	Squared length
`length()`	✅	Alias for magnitude
`length_squared()`	✅	Alias for magnitude_squared
`normalize()`	✅	Unit vector
`normalize_ip()`	✅	Normalize in-place
`is_normalized()`	✅	Check if unit length
`scale_to_length(length)`	✅	Scale to specific length
`reflect(normal)`	✅	Reflect across normal
`reflect_ip(normal)`	✅	Reflect in-place
`distance_to(other)`	✅	Distance between vectors
`distance_squared_to(other)`	✅	Squared distance
`rotate(angle)`	✅	Rotate vector (Vector2)
`rotate_ip(angle)`	✅	Rotate in-place (Vector2)
`rotate_rad(angle)`	✅	Rotate by radians (Vector2)
`rotate_rad_ip(angle)`	✅	Rotate in-place by radians
`angle_to(other)`	✅	Angle to other vector
`as_polar()`	❌	Convert to polar (r, theta)
`from_polar(polar)`	❌	Create from polar coordinates
`lerp(other, t)`	❌	Linear interpolation
`slerp(other, t)`	❌	Spherical interpolation
`smoothstep(other, t)`	❌	Smooth interpolation
`elementwise()`	❌	Element-wise operations
`move_towards(target, max_distance)`	❌	Move toward target
`move_towards_ip(target, max_distance)`	❌	Move toward in-place
`clamp_magnitude(max_length)`	❌	Clamp to max length
`clamp_magnitude_ip(max_length)`	❌	Clamp in-place
`clamp(min, max)`	❌	Module-level clamp function
`epsilon`	✅	Comparison epsilon
`copy()`	✅	Copy vector

pygame.mask

Item	Status	Notes
`Function/Method`	❌	Notes
`Mask(size, fill)`	✅	Create mask
`from_surface(surface, threshold)`	✅	Create from surface
`from_threshold(surface, color, threshold, ...)`	✅	Create from color threshold
`mask.copy()`	✅	Copy mask
`mask.get_size()`	✅	Get dimensions
`mask.get_at(pos)`	✅	Get bit at position
`mask.set_at(pos, value)`	✅	Set bit at position
`mask.overlap(other, offset)`	✅	Find overlap position
`mask.overlap_area(other, offset)`	✅	Count overlapping bits
`mask.overlap_mask(other, offset)`	✅	Create overlap mask
`mask.fill()`	✅	Fill with 1s
`mask.clear()`	✅	Fill with 0s
`mask.invert()`	✅	Invert bits
`mask.get_rect(**kwargs)`	✅	Get bounding rect
`mask.count()`	❌	Count set bits
`mask.centroid()`	❌	Calculate centroid
`mask.angle()`	❌	Calculate orientation angle
`mask.outline(every)`	❌	Get outline points
`mask.convolve(other, output, offset)`	❌	Convolve masks
`mask.connected_component(pos)`	❌	Get connected component
`mask.connected_components(minimum)`	❌	Get all components
`mask.get_bounding_rects()`	❌	Get all bounding rects
`mask.draw(other, offset)`	❌	Draw mask onto this
`mask.erase(other, offset)`	❌	Erase other from this
`mask.scale(size)`	❌	Scale mask
`mask.to_surface(...)`	❌	Convert to surface
`mask.from_surface()`	❌
`mask.from_threshold()`	❌

pygame.gfxdraw

Function	Status	Notes
`pixel(surface, x, y, color)`	❌	Single pixel (uses set_at)
`hline(surface, x1, x2, y, color)`	❌	Horizontal line
`vline(surface, x, y1, y2, color)`	❌	Vertical line
`rectangle(surface, rect, color)`	❌	Rectangle outline
`box(surface, rect, color)`	❌	Filled rectangle
`line(surface, x1, y1, x2, y2, color)`	❌	Line
`circle(surface, x, y, r, color)`	❌	Circle outline
`arc(surface, x, y, r, start, end, color)`	❌	Arc
`aacircle(surface, x, y, r, color)`	❌	Anti-aliased circle
`filled_circle(surface, x, y, r, color)`	❌	Filled circle
`ellipse(surface, x, y, rx, ry, color)`	❌	Ellipse outline
`aaellipse(surface, x, y, rx, ry, color)`	❌	Anti-aliased ellipse
`filled_ellipse(surface, x, y, rx, ry, color)`	❌	Filled ellipse
`pie(surface, x, y, r, start, end, color)`	❌	Pie slice
`trigon(surface, x1, y1, x2, y2, x3, y3, color)`	❌	Triangle
`aatrigon(surface, x1, y1, x2, y2, x3, y3, color)`	❌	AA triangle
`filled_trigon(surface, x1, y1, x2, y2, x3, y3, color)`	❌	Filled triangle
`polygon(surface, points, color)`	❌	Polygon outline
`aapolygon(surface, points, color)`	❌	AA polygon
`filled_polygon(surface, points, color)`	❌	Filled polygon
`textured_polygon(surface, points, texture, tx, ty)`	❌	Textured polygon
`bezier(surface, points, steps, color)`	❌	Bezier curve
`gfxdraw.aacircle()`	❌
`gfxdraw.aaellipse()`	❌
`gfxdraw.aapolygon()`	❌
`gfxdraw.aatrigon()`	❌
`gfxdraw.arc()`	❌
`gfxdraw.bezier()`	❌
`gfxdraw.box()`	❌
`gfxdraw.circle()`	❌
`gfxdraw.ellipse()`	❌
`gfxdraw.filled_circle()`	❌
`gfxdraw.filled_ellipse()`	❌
`gfxdraw.filled_polygon()`	❌
`gfxdraw.filled_trigon()`	❌
`gfxdraw.hline()`	❌
`gfxdraw.line()`	❌
`gfxdraw.pie()`	❌
`gfxdraw.pixel()`	❌
`gfxdraw.polygon()`	❌
`gfxdraw.rectangle()`	❌
`gfxdraw.textured_polygon()`	❌
`gfxdraw.trigon()`	❌
`gfxdraw.vline()`	❌

pygame.surfarray

Function	Status	Notes
`array2d(surface)`	✅	2D pixel array (grayscale)
`array3d(surface)`	✅	3D RGB array
`pixels2d(surface)`	✅	2D view (writable)
`pixels3d(surface)`	✅	3D view (writable)
`array_alpha(surface)`	❌	Alpha channel array
`array_colorkey(surface)`	❌	Colorkey array
`make_surface(array)`	✅	Create surface from array
`blit_array(surface, array)`	❌	Blit array to surface
`map_array(surface, array)`	❌	Map colors to pixel values
`use_arraytype(arraytype)`	❌	Set array type (always numpy)
`get_arraytype()`	❌	Returns “numpy”
`get_arraytypes()`	❌	Returns [“numpy”]
`surfarray.array2d()`	❌
`surfarray.array3d()`	❌
`surfarray.array_alpha()`	❌
`surfarray.array_blue()`	❌
`surfarray.array_colorkey()`	❌
`surfarray.array_green()`	❌
`surfarray.array_red()`	❌
`surfarray.array_to_surface()`	❌
`surfarray.blit_array()`	❌
`surfarray.make_surface()`	❌
`surfarray.map_array()`	❌
`surfarray.pixels2d()`	❌
`surfarray.pixels3d()`	❌
`surfarray.pixels_alpha()`	❌
`surfarray.pixels_blue()`	❌
`surfarray.pixels_green()`	❌
`surfarray.pixels_red()`	❌
`surfarray.surface_to_array()`	❌

pygame.pixelcopy

Function	Status	Notes
`surface_to_array(array, surface, kind, opaque, ...)`	❌	Fast surface to array copy
`array_to_surface(surface, array)`	❌	Fast array to surface copy
`map_array(surface, array3d, array2d)`	❌	Map RGB to pixel values
`make_surface(array)`	❌	Create surface from array
`pixelcopy.array_to_surface()`	❌
`pixelcopy.make_surface()`	❌
`pixelcopy.map_array()`	❌
`pixelcopy.surface_to_array()`	❌

pygame.mixer

Item	Status	Notes
`Function/Class`	❌	Notes
`mixer.init(...)`	🚫	Audio initialization
`mixer.pre_init(...)`	🚫	Pre-initialize mixer
`mixer.quit()`	🚫	Uninitialize mixer
`mixer.get_init()`	🚫	Get audio settings
`mixer.stop()`	🚫	Stop all channels
`mixer.pause()`	🚫	Pause all channels
`mixer.unpause()`	🚫	Unpause all channels
`mixer.fadeout(time)`	🚫	Fade out all sounds
`mixer.set_num_channels(count)`	🚫	Set channel count
`mixer.get_num_channels()`	🚫	Get channel count
`mixer.set_reserved(count)`	🚫	Reserve channels
`mixer.find_channel(force)`	🚫	Find available channel
`mixer.get_busy()`	🚫	Check if any sound playing
`Sound(file)`	🚫	Sound object
`Sound.play(loops, maxtime, fade_ms)`	🚫	Play sound
`Sound.stop()`	🚫	Stop sound
`Sound.fadeout(time)`	🚫	Fade out sound
`Sound.set_volume(value)`	🚫	Set volume
`Sound.get_volume()`	🚫	Get volume
`Sound.get_num_channels()`	🚫	Active channels
`Sound.get_length()`	🚫	Sound duration
`Channel(id)`	🚫	Channel object
`Channel.play(sound, ...)`	🚫	Play on channel
`Channel.stop()`	🚫	Stop channel
`Channel.pause()`	🚫	Pause channel
`Channel.unpause()`	🚫	Unpause channel
`Channel.fadeout(time)`	🚫	Fade out channel
`Channel.set_volume(left, right)`	🚫	Set channel volume
`Channel.get_volume()`	🚫	Get channel volume
`Channel.get_busy()`	🚫	Check if playing
`Channel.get_sound()`	🚫	Get current sound
`Channel.queue(sound)`	🚫	Queue sound
`Channel.get_queue()`	🚫	Get queued sound

pygame.mixer.music

Function	Status	Notes
`music.load(file)`	🚫	Load music file
`music.unload()`	🚫	Unload music
`music.play(loops, start, fade_ms)`	🚫	Play music
`music.rewind()`	🚫	Restart music
`music.stop()`	🚫	Stop music
`music.pause()`	🚫	Pause music
`music.unpause()`	🚫	Unpause music
`music.fadeout(time)`	🚫	Fade out music
`music.set_volume(volume)`	🚫	Set volume
`music.get_volume()`	🚫	Get volume
`music.get_busy()`	🚫	Check if playing
`music.set_pos(pos)`	🚫	Set position
`music.get_pos()`	🚫	Get position
`music.queue(file)`	🚫	Queue next music
`music.set_endevent(type)`	🚫	Set end event
`music.get_endevent()`	🚫	Get end event

pygame.joystick

Item	Status	Notes
`Function/Method`	❌	Notes
`joystick.init()`	🚫	Initialize joystick
`joystick.quit()`	🚫	Uninitialize joystick
`joystick.get_init()`	🚫	Get init status
`joystick.get_count()`	🚫	Number of joysticks
`Joystick(id)`	🚫	Joystick object
`Joystick.init()`	🚫	Initialize stick
`Joystick.quit()`	🚫	Uninitialize stick
`Joystick.get_init()`	🚫	Get init status
`Joystick.get_id()`	🚫	Get joystick ID
`Joystick.get_instance_id()`	🚫	Get instance ID
`Joystick.get_guid()`	🚫	Get GUID
`Joystick.get_power_level()`	🚫	Get battery level
`Joystick.get_name()`	🚫	Get joystick name
`Joystick.get_numaxes()`	🚫	Number of axes
`Joystick.get_axis(axis)`	🚫	Get axis value
`Joystick.get_numballs()`	🚫	Number of trackballs
`Joystick.get_ball(ball)`	🚫	Get ball movement
`Joystick.get_numbuttons()`	🚫	Number of buttons
`Joystick.get_button(button)`	🚫	Get button state
`Joystick.get_numhats()`	🚫	Number of hats
`Joystick.get_hat(hat)`	🚫	Get hat position
`Joystick.rumble(low, high, duration)`	🚫	Rumble effect
`Joystick.stop_rumble()`	🚫	Stop rumble

pygame.camera

Item	Status	Notes
`Function/Class`	❌	Notes
`camera.init()`	❌	Raises NotImplementedError
`camera.get_backends()`	❌	Raises NotImplementedError
`camera.colorspace(surface, format, dest_surface)`	❌	Raises NotImplementedError
`camera.list_cameras()`	❌	Raises NotImplementedError
`Camera(device, size, format)`	❌	Raises NotImplementedError
`Camera.start()`	❌	Raises NotImplementedError
`Camera.stop()`	❌	Raises NotImplementedError
`Camera.get_controls()`	❌	Raises NotImplementedError
`Camera.set_controls()`	❌	Raises NotImplementedError
`Camera.get_size()`	❌	Raises NotImplementedError
`Camera.query_image()`	❌	Raises NotImplementedError
`Camera.get_image(surface)`	❌	Raises NotImplementedError
`Camera.get_raw()`	❌	Raises NotImplementedError

pygame.freetype

Item	Status	Notes
`Function/Class`	❌	Notes
`freetype.init()`	❌	Stub raises NotImplementedError
`freetype.quit()`	❌	Stub raises NotImplementedError
`freetype.get_init()`	❌	Stub raises NotImplementedError
`freetype.get_default_font()`	❌	Stub raises NotImplementedError
`freetype.get_default_resolution()`	❌	Stub raises NotImplementedError
`freetype.set_default_resolution(dpi)`	❌	Stub raises NotImplementedError
`freetype.SysFont(name, size, bold, italic)`	❌	Stub raises NotImplementedError
`Font(file, size, ...)`	❌	Stub raises NotImplementedError
`freetype.get_version()`	❌
`freetype.was_init()`	❌

pygame.cursors

Item	Status	Notes
`Function/Class`	❌	Notes
`cursors.compile(strings, black, white, xor)`	❌	Stub
`cursors.load_xbm(cursorfile, maskfile)`	❌	Stub
`Cursor(constant)`	❌	System cursor constant
`Cursor constants`	❌	SYSTEM_CURSOR_* constants

pygame.midi

Item	Status	Notes
`Function/Class`	❌	Notes
`midi.init()`	❌	Stub raises NotImplementedError
`midi.quit()`	❌	Stub raises NotImplementedError
`midi.get_init()`	❌	Stub raises NotImplementedError
`midi.get_count()`	❌	Stub raises NotImplementedError
`midi.get_default_input_id()`	❌	Stub raises NotImplementedError
`midi.get_default_output_id()`	❌	Stub raises NotImplementedError
`midi.get_device_info(device_id)`	❌	Stub raises NotImplementedError
`midi.midis2events(midi_events, device_id)`	❌	Stub raises NotImplementedError
`midi.time()`	❌	Stub raises NotImplementedError
`midi.frequency_to_midi(freq)`	❌	Stub raises NotImplementedError
`midi.midi_to_frequency(midi_note)`	❌	Stub raises NotImplementedError
`midi.midi_to_ansi_note(midi_note)`	❌	Stub raises NotImplementedError
`Input(device_id, buffer_size)`	❌	Stub raises NotImplementedError
`Output(device_id, latency, buffer_size)`	❌	Stub raises NotImplementedError

pygame.sndarray

Function	Status	Notes
`sndarray.array(sound)`	❌	Stub raises NotImplementedError
`sndarray.samples(sound)`	❌	Stub raises NotImplementedError
`sndarray.make_sound(array)`	❌	Stub raises NotImplementedError
`sndarray.use_arraytype(arraytype)`	❌	Stub raises NotImplementedError
`sndarray.get_arraytype()`	❌	Stub raises NotImplementedError
`sndarray.get_arraytypes()`	❌	Stub raises NotImplementedError

pygame.scrap

Function	Status	Notes
`scrap.init()`	❌	Not present
`scrap.quit()`	❌	Not present
`scrap.get_init()`	❌	Not present
`scrap.get(type)`	❌	Not present
`scrap.put(type, data)`	❌	Not present
`scrap.contains(type)`	❌	Not present
`scrap.lost()`	❌	Not present
`scrap.set_mode(mode)`	❌	Not present

pygame.Window

Method	Status	Notes
`Window(title, size, ...)`	❌	Window management class
`Window.from_display_module()`	❌	Get window from display
`Window.grab_keyboard()`	❌	Keyboard grab
`Window.release_keyboard()`	❌	Release keyboard
`Window.set_windowed()`	❌	Windowed mode
`Window.set_fullscreen(desktop)`	❌	Fullscreen mode
`Window.get_surface()`	❌	Get window surface
`Window.flip()`	❌	Flip window
`Window.destroy()`	❌	Destroy window
`Window.hide()`	❌	Hide window
`Window.show()`	❌	Show window
`Window.focus()`	❌	Focus window
`Window.restore()`	❌	Restore window
`Window.maximize()`	❌	Maximize window
`Window.minimize()`	❌	Minimize window
`Window.set_title(title)`	❌	Set title
`Window.title`	❌	Window title property
`Window.set_icon(surface)`	❌	Set icon
`Window.size`	❌	Window size property
`Window.position`	❌	Window position property
`Window.opacity`	❌	Window opacity property
`Window.resizable`	❌	Resizable property
`Window.borderless`	❌	Borderless property

pygame.geometry

Class/Method	Status	Notes
`Circle(x, y, r)`	❌	Circle class
`Circle.x, Circle.y, Circle.r`	❌	Properties
`Circle.center`	❌	Center point
`Circle.r_sqr`	❌	Radius squared
`Circle.area`	❌	Calculate area
`Circle.circumference`	❌	Calculate circumference
`Circle.rotate(angle)`	❌	Rotate around point
`Circle.rotate_ip(angle)`	❌	Rotate in-place
`Circle.update(x, y, r)`	❌	Update values
`Circle.move(x, y)`	❌	Move circle
`Circle.move_ip(x, y)`	❌	Move in-place
`Circle.collidepoint(x, y)`	❌	Point collision
`Circle.colliderect(rect)`	❌	Rect collision
`Circle.collidecircle(circle)`	❌	Circle collision
`Circle.intersect(circle)`	❌	Circle intersection
`Circle.as_rect()`	❌	Bounding rect
`Circle.as_frect()`	❌	Bounding frect
`Line(x1, y1, x2, y2)`	❌	Line segment class
`Line.a, Line.b`	❌	Endpoint properties
`Line.update(x1, y1, x2, y2)`	❌	Update endpoints
`Line.move(x, y)`	❌	Move line
`Line.move_ip(x, y)`	❌	Move in-place
`Line.flip_ab()`	❌	Swap endpoints
`Line.flip_ab_ip()`	❌	Swap in-place

pygame.system

Function	Status	Notes
`system.get_cpu_instruction_sets()`	❌	CPU feature detection
`system.get_total_ram()`	❌	Total system RAM
`system.get_pref_path(org, app)`	❌	Get preferences path
`system.get_pref_locales()`	❌	Get locale preferences
`system.get_power_state()`	❌	Battery/power info

Summary Statistics

Item	Status	Notes
`Status`	❌	Percentage
`✅ Fully Implemented`	❌	45.2%
`🔶 Partially Implemented`	❌	6.9%
`❌ Not Implemented`	❌	24.0%
`🚫 Not Applicable (Jupyter limitations)`	❌	24.0%
`Category`	❌	Status
`Core (init, quit, error)`	❌	✅ Excellent
`Display & Surface`	❌	✅ Very Good
`Drawing (draw, gfxdraw)`	❌	✅ Excellent
`Events & Input`	❌	✅ Good
`Time & Clock`	❌	✅ Excellent
`Fonts`	❌	🔶 Good
`Images & Transform`	❌	✅ Excellent
`Sprites & Collision`	❌	🔶 Good
`Colors & Rects`	❌	✅ Excellent
`Math (Vector2/3)`	❌	🔶 Fair
`Masks`	❌	🔶 Limited
`Audio (mixer, music, sndarray)`	❌	🚫 N/A
`Joystick`	❌	🚫 N/A
`Camera`	❌	🚫 N/A
`Advanced (Window, geometry, system)`	❌	❌ Not Implemented

API Coverage

Table of Contents

Core Module (pygame)

pygame.display

pygame.Surface

pygame.draw

pygame.event

pygame.key

pygame.mouse

pygame.time

pygame.font

pygame.image

pygame.transform

pygame.sprite

pygame.Rect / FRect

pygame.Color

pygame.math

pygame.mask

pygame.gfxdraw

pygame.surfarray

pygame.pixelcopy

pygame.mixer

pygame.mixer.music

pygame.joystick

pygame.camera

pygame.freetype

pygame.cursors

pygame.midi

pygame.sndarray

pygame.scrap

pygame.Window

pygame.geometry

pygame.system

Summary Statistics