calling comp.render() and capturing recursively
191697
function _capture (state, vel, mode) {
  if (state.is(CAPTURED, vel)) {
    return vel
  }
  // a captured VirtualElement has a component instance attached
  let comp = vel._comp
  if (!comp) {
    comp = _create(state, vel)
    state.set(NEW, vel)
  }
  if (vel._isVirtualComponent) {
    let needRerender
    // NOTE: forceCapture is used for the first entrance
    // from this.render(comp) where we want to fource capturing
    // as it has already been cleared that a rerender is necessary
    if (mode === TOP_LEVEL_ELEMENT) {
      needRerender = true
      // top-level comp and virtual component are linked per se
      console.assert(vel._comp === comp, 'top-level element and component should be linked already')
      state.set(MAPPED, vel)
      state.set(MAPPED, comp)
      state.set(LINKED, vel)
      state.set(LINKED, comp)
      let compData = _getInternalComponentData(comp)
      vel.elementProps = compData.elementProps
    } else {
      // NOTE: don't ask shouldRerender if no element is there yet
      needRerender = !comp.el || comp.shouldRerender(vel.props, comp.state)
      // Note: in case of VirtualComponents there are typically two actors setting element properties:
      // the component instance itself, and the owner, such as in
      // `$$(Foo).addClass('se-foo')`
      // To be able to retain the element properties set by the parent, we have to bring them out of the way
      // before capturing the component
      vel.elementProps = vel._copy()
      vel._clear()
      state.set(OLDPROPS, vel, comp.props)
      state.set(OLDSTATE, vel, comp.state)
      // updates prop triggering willReceiveProps
      comp._setProps(vel.props)
      if (!state.is(NEW, vel)) {
        state.set(UPDATED, vel)
      }
    }
    if (needRerender) {
      let context = new VirtualElement.Context(vel)
      let content = comp.render(context.$$)
      if (!content) {
        throw new Error('Component.render() returned nil.')
      } else if (content._isVirtualComponent) {
        // allowing for forwarding components
        // content needs to have a parent for creating components
        vel._forwardedEl = content
        vel._isForwarding = true
        content._isForwarded = true
        content.parent = vel
        vel.children = [content]
      } else if (content._isVirtualHTMLElement) {
        // merge the content into the VirtualComponent instance
        vel.tagName = content.tagName
        vel._merge(content)
        if (content.hasInnerHTML()) {
          vel._innerHTMLString = content._innerHTMLString
          vel.children = []
        } else {
          vel.children = content.children
          // adopting the children
          vel.children.forEach(child => {
            child.parent = vel
          })
        }
      } else {
        throw new Error('render() must return a plain element or a Component')
      }
      // retain the rendering context
      vel._context = content._context

      // augmenting the element properties with those given by the owner
      // such as in $$(Foo, { child: $$(Bar).addClass('') })
      if (vel.elementProps) {
        vel._merge(vel.elementProps)
        // augment a forwarded virtual component with the accumlated element properties
        // (works also for injected, forwarding components
        if (vel._isForwarding) {
          vel._forwardedEl._merge(vel)
        }
      }

      // TODO: document what this is used for
      if (!state.is(NEW, vel) && comp.isMounted()) {
        state.set(UPDATED, vel)
      }

      // ATTENTION: before capturing we need to link VirtualComponents with
      // existing Components so that `render()` can be called on the
      // correct instances.
      _forEachComponent(state, comp, vel, _linkComponent)

      // Descending
      if (substanceGlobals.DEBUG_RENDERING) {
        // in this case we use the render() function as iterating function,
        // where `$$` is a function which creates components and renders them
        // recursively. First we can create all element components that can be
        // reached without recursion
        let stack = vel.children.slice(0)
        while (stack.length) {
          let child = stack.shift()
          if (state.is(CAPTURED, child)) continue
          // virtual components are addressed via recursion, not captured here
          if (child._isVirtualComponent) continue
          if (!child._comp) {
            _create(state, child)
          }
          if (child._isVirtualHTMLElement && child.children.length > 0) {
            stack = stack.concat(child.children)
          }
          state.set(CAPTURED, child)
        }
        // then we run comp.render($$) with a special $$ that captures
        // VirtualComponents recursively
        let descendingContext = new DescendingContext(state, context)
        while (descendingContext.hasPendingCaptures()) {
          descendingContext.reset()
          comp.render(descendingContext.$$)
        }
        // capture injected components recursively
        // for the case that the owner is not re-rendered
        for (let child of context.injectedComponents) {
          _capture(state, child)
        }
        // TODO: this can be improved. It would be better if _capture was called
        // by DescendingContext() then the forwarded component would be rendered
        // during the render() call of the forwarding component
        if (vel._forwardedEl) {
          _capture(state, vel._forwardedEl)
        }
      } else {
        // ATTENTION: without DEBUG_RENDERING enabled the content is captured
        // outside of the `render()` call stack i.e. `render()` has finished
        // already and provided a virtual element. Children component are
        // rendered as part of this recursion, i.e. in the stack trace there
        // will be `RenderingEngine._capture()` only
        if (vel._forwardedEl) {
          _capture(state, vel._forwardedEl)
        } else {
          for (let child of vel.children) {
            _capture(state, child)
          }
        }
      }
      _forEachComponent(state, comp, vel, _propagateLinking)
    } else {
      // SKIPPED are those components who have returned `shouldRerender() = false`
      state.set(SKIPPED, vel)
    }
  } else if (vel._isVirtualHTMLElement) {
    for (let child of vel.children) {
      _capture(state, child)
    }
  }

  state.set(CAPTURED, vel)
  return vel
}
923840
def render(self, context, db=None, safe_mode=False, extra_context=None):
        """"""
        if not db:
            raise MissingParameterError(
                "db",
                context=self.error_context
            )
        rendered_views = dict()
        path_instances = db.query(self.path.query, safe_mode=safe_mode)
        extra_ctx = copy(extra_context) if extra_context else dict()

        for inst in path_instances:
            extra_ctx.update({
                self.path.variable: inst
            })
            ctx = context.build(
                db=db,
                safe_mode=safe_mode,
                for_each_inst=inst,
                extra=extra_ctx
            )
            inst_path = self.path.render(inst=inst, context=ctx)
            rendered_view = self.template.render(ctx)
            rendered_views = deep_merge_dict(
                rendered_views,
                dict_from_path(inst_path, final_value=rendered_view)
            )
        return rendered_views
822138
async function render(template) {
	const content = {
		badges: await badges(argv.context),
		usage: ''
	}

	if (argv.usage) {
		content.usage = readFileSync(resolve(argv.usage))
	}

	const page = await remark().use(gap).use(squeeze).process(template(content))
	process.stdout.write(page.toString())
}
290318
function(vars) {
    var c = this.compiled = this.compiled || this.get('compiled') || this.compile();
    var rendered = c(vars);
    return rendered;
  }
926254
def render_value(value):
    """"""
    if isinstance(value, list):
        return '[' + ', '.join(render_value(v) for v in value) + ']'
    elif isinstance(value, dict):
        return (
            '{' +
            ', '.join('{k!r}: {v}'.format(
                k=k, v=render_value(v)) for k, v in sorted(value.items())) +
            '}')
    else:
        return repr(value)
154877
function renderNode(node, children = []) {
    [...children].forEach(child => {
        if (child && child.tag) {
            node.ele(child.tag, child.props);
            renderNode(node, child.children);
            node.end();
        } else {
            node.text(child);
        }
    });
}
519388
function(){

    var gl = this.gl;
    gl.bindRenderbuffer(    RENDERBUFFER,  this.id );
    gl.renderbufferStorage( RENDERBUFFER,  this.format , this.width, this.height );
    gl.bindRenderbuffer(    RENDERBUFFER,  null );

  }
875552
function renderList (
  val,
  render
) {
  var ret, i, l, keys, key;
  if (Array.isArray(val) || typeof val === 'string') {
    ret = new Array(val.length);
    for (i = 0, l = val.length; i < l; i++) {
      ret[i] = render(val[i], i);
    }
  } else if (typeof val === 'number') {
    ret = new Array(val);
    for (i = 0; i < val; i++) {
      ret[i] = render(i + 1, i);
    }
  } else if (isObject(val)) {
    if (hasSymbol && val[Symbol.iterator]) {
      ret = [];
      var iterator = val[Symbol.iterator]();
      var result = iterator.next();
      while (!result.done) {
        ret.push(render(result.value, ret.length));
        result = iterator.next();
      }
    } else {
      keys = Object.keys(val);
      ret = new Array(keys.length);
      for (i = 0, l = keys.length; i < l; i++) {
        key = keys[i];
        ret[i] = render(val[key], key, i);
      }
    }
  }
  if (!isDef(ret)) {
    ret = [];
  }
  (ret)._isVList = true;
  return ret
}
861612
def write_render_callable(self, node, name, args, buffered, filtered,
            cached):
        """"""

        if self.in_def:
            decorator = node.decorator
            if decorator:
                self.printer.writeline(
                                "@runtime._decorate_toplevel(%s)" % decorator)

        self.printer.start_source(node.lineno)
        self.printer.writelines(
            "def %s(%s):" % (name, ','.join(args)),
                # push new frame, assign current frame to __M_caller
                "__M_caller = context.caller_stack._push_frame()",
                "try:"
        )
        if buffered or filtered or cached:
            self.printer.writeline("context._push_buffer()")

        self.identifier_stack.append(
                                self.compiler.identifiers.branch(self.node))
        if (not self.in_def or self.node.is_block) and '**pageargs' in args:
            self.identifier_stack[-1].argument_declared.add('pageargs')

        if not self.in_def and (
                                len(self.identifiers.locally_assigned) > 0 or
                                len(self.identifiers.argument_declared) > 0
                                ):
            self.printer.writeline("__M_locals = __M_dict_builtin(%s)" %
                                    ','.join([
                                            "%s=%s" % (x, x) for x in
                                            self.identifiers.argument_declared
                                            ]))

        self.write_variable_declares(self.identifiers, toplevel=True)

        for n in self.node.nodes:
            n.accept_visitor(self)

        self.write_def_finish(self.node, buffered, filtered, cached)
        self.printer.writeline(None)
        self.printer.write_blanks(2)
        if cached:
            self.write_cache_decorator(
                                node, name,
                                args, buffered,
                                self.identifiers, toplevel=True)
526759
def render(cls, obj):
        
        class_hierarchy = inspect.getmro(type(obj))
        hooks = []
        for _, type_hooks in cls._display_hooks.items():
            for cls in class_hierarchy:
                if cls in type_hooks:
                    hooks.append(type_hooks[cls])
                    break

        data, metadata = {}, {}
        for hook in hooks:
            ret = hook(obj)
            if ret is None:
                continue
            d, md = ret
            data.update(d)
            metadata.update(md)
        return data, metadata
963043
function render(element) {
    // Is the given element valid?
    invariant(
        ReactElement.isValidElement(element),
        'render(): You must pass a valid ReactElement.'
    );

    const id = ReactInstanceHandles.createReactRootID(); // Creating a root id & creating the screen
    const component = instantiateReactComponent(element); // Mounting the app
    const transaction = ReactUpdates.ReactReconcileTransaction.getPooled();

    ReactWWIDOperations.setRoot(new WorkerDomNodeStub('0', 'div', {}));

    // The initial render is synchronous but any updates that happen during
    // rendering, in componentWillMount or componentDidMount, will be batched
    // according to the current batching strategy.
    ReactUpdates.batchedUpdates(() => {
        transaction.perform(() => {
            component.mountComponent(id, transaction, {});
        });
        ReactUpdates.ReactReconcileTransaction.release(transaction);
    });

    return component._instance;
}
311276
def render(self, *args, **kwargs):
        """"""
        # args kwargs API provided for last minute content injection
        # self._reverse_mro_func('pre_render')
        pretty = kwargs.pop("pretty", False)
        if pretty and self._stable != "pretty":
            self._stable = False

        for arg in args:
            self._stable = False
            if isinstance(arg, dict):
                self.inject(arg)
        if kwargs:
            self._stable = False
            self.inject(kwargs)

        # If the tag or his contents are not changed and we already have rendered it
        # with the same attrs we skip all the work
        if self._stable and self._render:
            return self._render

        pretty_pre = pretty_inner = ""
        if pretty:
            pretty_pre = "\n" + ("\t" * self._depth) if pretty else ""
            pretty_inner = "\n" + ("\t" * self._depth) if len(self.childs) > 1 else ""
        inner = self.render_childs(pretty) if not self._void else ""

        # We declare the tag is stable and have an official render:
        tag_data = (
            pretty_pre,
            self._get__tag(),
            self.render_attrs(),
            inner,
            pretty_inner,
            self._get__tag()
        )[: 6 - [0, 3][self._void]]
        self._render = self._template % tag_data
        self._stable = "pretty" if pretty else True
        return self._render
1337399
function compile() {
        debug('read %s', cssPath);
        fs.readFile(stylusPath, 'utf8', function(err, str){
          if (err) return error(err);
          var style = options.compile(str, stylusPath);
          var paths = style.options._imports = [];
          imports[stylusPath] = null;
          style.render(function(err, css){
            if (err) return next(err);
            debug('render %s', stylusPath);
            imports[stylusPath] = paths;
            mkdir(dirname(cssPath), { mode: parseInt('0700', 8), recursive: true }, function(err){
              if (err) return error(err);
              fs.writeFile(cssPath, css, 'utf8', next);
            });
          });
        });
      }
759242
def render(*args, &block)
      captured = helpers.capture do
        helpers.concat(helpers.render(*args, &block))
        helpers.output_buffer.to_s
      end
      rawtext(captured)
    end
99406
def render(self, target, data):
        """"""
        rows = self.get_rows(target, data)
        rows = self._filter_rows(rows)
        renderer = getattr(self, "_render_%s" % target.name, None)
        if renderer is None:
            raise ValueError(
                "Cannot render %r for %s." % (self.value, target))
        else:
            return renderer(rows)
544938
function renderObjectImmediate( object, program ) {

		object.render( function ( object ) {

			_this.renderBufferImmediate( object, program );

		} );

	}
792053
function render(template, locals, layoutTemplates, cb) {
    if (!layoutTemplates) layoutTemplates = [];

    // We'll render templates from bottom to top of the stack, each template
    // being passed the rendered string of the previous ones as `body`
    var i = layoutTemplates.length - 1;

    var _stackRenderer = function(err, htmlStr) {
      if (err) return cb(err);

      if (i >= 0) {
        locals.body = htmlStr;
        renderTemplate(layoutTemplates[i--], locals, _stackRenderer);
      } else {
        cb(null, htmlStr);
      }
    };

    // Start the rendering with the innermost page template
    renderTemplate(template, locals, _stackRenderer);
  }