functor (R : Renderer.Renderer) ->
  sig
    val string_of_char : char -> string
    val char_of_string : string -> char
    val ( ~. ) : int -> float
    module Math = Math.Math
    module Vector = Math.Vector
    type vector = Vector.t
    type keys = Set.Make(Uchar).t
    type config =
      Config.config = {
      width : int;
      height : int;
      display_width : int;
      display_height : int;
      mouse_x : int;
      mouse_y : int;
      pmouse_x : int;
      pmouse_y : int;
      mouse_scroll : int;
      mouse_pressed : bool;
      mouse_button : [ `Center | `Left | `Right ];
      key : char;
      keys : keys;
      key_unicode : Uchar.t;
      key_pressed : bool;
      frame_count : int;
      frame_rate : float;
    }
    val check_key : config -> char -> bool
    val check_key_uchar : config -> Uchar.t -> bool
    val get_keys : config -> char list
    val get_keys_uchar : config -> Uchar.t list
    exception Exit
    type color =
      Color.color = {
      red : int;
      green : int;
      blue : int;
      alpha : int;
    }
    val rgb : int -> int -> int -> color
    val rgba : int -> int -> int -> int -> color
    val gray : int -> color
    val graya : int -> int -> color
    val hsv : int -> int -> int -> color
    val hsva : int -> int -> int -> int -> color
    val hex : string -> color
    module Key = Key.Key
    module KeyUnicode = Key.KeyUnicode
    type tag = Shape.tag = ..
    type tag += TName of string
    type vertex =
      Shape.vertex = private
        MoveTo of Math.vector
      | LineTo of Math.vector
      | BezierTo of Math.vector * Math.vector * Math.vector
      | Arc of Math.vector * Math.vector * float * float * float
      | ClosePath
    type t =
      Shape.t = private
        Shape of vertex list
      | Group of t list
      | Paint of t * Paint.paint_update
      | Tag of t * tag
      | Background of Color.color
      | Empty
    val poly : ?close:[ `Close | `Open ] -> Math.vector list -> t
    val point : Math.vector -> t
    val line : Math.vector -> Math.vector -> t
    val rect :
      Math.vector -> ?align:[ `Center | `Corner ] -> Math.vector -> t
    val quad : Math.vector -> Math.vector -> Math.vector -> Math.vector -> t
    val triangle : Math.vector -> Math.vector -> Math.vector -> t
    val ellipse :
      Math.vector -> ?align:[ `Center | `Corner ] -> Math.vector -> t
    val circle : Math.vector -> ?align:[ `Center | `Corner ] -> float -> t
    val arc :
      Math.vector ->
      ?align:[ `Center | `Corner ] ->
      Math.vector ->
      ?stroke_mode:[ `Closed | `Open ] ->
      ?fill_mode:[ `Chord | `Pie ] -> ?phi:float -> float -> float -> t
    val bezier : Bezier.t -> t
    val group : t list -> t
    val shape : t -> Math.vector -> t
    val background : Color.color -> t
    val empty : t
    val fill : Color.color -> t -> t
    val no_fill : t -> t
    val stroke : Color.color -> t -> t
    val no_stroke : t -> t
    val stroke_weight : float -> t -> t
    val stroke_cap : [ `Project | `Round | `Square ] -> t -> t
    val stroke_join : [ `Bevel | `Miter | `Round ] -> t -> t
    val bleach : t -> t
    val name : string -> t -> t
    val find_name : string -> t -> t option
    val find_names : string -> t -> t list
    val tag : tag -> t -> t
    val find_tag : ?eq:(tag -> tag -> bool) -> tag -> t -> t option
    val find_tags : ?eq:(tag -> tag -> bool) -> tag -> t -> t list
    val translate : Math.vector -> t -> t
    val scale : Math.vector -> t -> t
    val rotate : float -> t -> t
    module Dynamic = Runner.Dynamic
    module Runner = Runner.Runner
    val run_sketch : (module Sketch.Sketch) -> unit
    module Dict = Core.Dict
    module type Sketch = Sketch.Sketch
    module Base :
      sig
        module R :
          sig
            type buffer = R.buffer
            val create_buffer : float -> Renderer.display -> buffer
            val begin_draw : buffer -> unit
            val end_draw : buffer -> unit
            val clear : buffer -> unit
            val event_queue : buffer -> Renderer.event list
            val width : buffer -> int
            val height : buffer -> int
            val render : buffer -> Shape.t -> unit
          end
        val display : [> `Size of int * int ]
        val loop : 'a -> 'b -> 'b
        val draw : 'a -> 'b -> Shape.t
        val mouse_pressed : 'a -> 'b -> 'b
        val mouse_released : 'a -> 'b -> 'b
        val mouse_moved : 'a -> 'b -> 'b
        val mouse_dragged : 'a -> 'b -> 'b
        val mouse_clicked : 'a -> 'b -> 'b
        val mouse_scrolled : 'a -> 'b -> 'b
        val key_pressed : 'a -> 'b -> 'b
        val key_released : 'a -> 'b -> 'b
        val key_typed : 'a -> 'b -> 'b
        val window_resized : 'a -> 'b -> 'b
        val window_closed : 'a -> 'b -> 'c
      end
  end