Can I render to a custom output file format?
I don't think that's possible, without adding this to the source and compile it. As workaround you can try to create a custom render engine class and create property to add a path to your application like this:



The following script creates a discription scene file (text) for every frame you've selected in the scene and uses custom application to render it:

import bpy
import mathutils
from mathutils import Vector

# LOGIC
class CustomRenderEngine(bpy.types.RenderEngine):

    # These three members are used by blender to set up the
    # RenderEngine; define its internal name, visible name and capabilities.
    bl_idname = 'custom_renderer'
    bl_label = 'Application Name'
    bl_use_preview = True

    def formatNumbers(self, number):
        return '%0*d' % (4, number)

    def get_allObjectsInSceneByType(self, type_string):
        objects = []
        for objs in bpy.data.objects: # searches for type in the selection
            if (objs.type == type_string):
                if objs.hide == True:
                    pass
                else:
                    objects.append(objs)
        return objects

    # Return Object Transformations
    def get_objectLocation(self, object):
        return bpy.data.objects[object.name].location

    def get_objectRotation(self, object):
        return bpy.data.objects[object.name].rotation_euler

    def get_objectScale(self, object):
        return bpy.data.objects[object.name].scale

    # Return Geo Type
    def get_geoType(self, object):
        verticies = []
        for vertex in object.data.vertices:  
            verticies.append(vertex.co)
        if len(verticies) == 8:
            return "CUBE"
        else:
            return "SPHERE"

    # Return verticies of Object
    def get_objectVerts(self, object):
        verticies = []
        for vertex in object.data.vertices:  
            verticies.append(vertex.co)
            #print (vertex.co)
        return verticies

    # Return Geo Center 
    def get_GeometryCenter(self,obj):

        sumWCoord = [0,0,0]
        numbVert = 0
        if obj.type == 'MESH':
            for vert in obj.data.vertices:
                wmtx = obj.matrix_world
                worldCoord = vert.co * wmtx
                sumWCoord[0] += worldCoord[0]
                sumWCoord[1] += worldCoord[1]
                sumWCoord[2] += worldCoord[2]
                numbVert += 1
            sumWCoord[0] = sumWCoord[0]/numbVert
            sumWCoord[1] = sumWCoord[1]/numbVert
            sumWCoord[2] = sumWCoord[2]/numbVert
        return sumWCoord

    # Return max vert distance
    def max_vertDistance(self, ob):

        verts = ob.data.vertices
        centre = Vector([0,0,0])
        for vert in verts:
            centre += vert.co

        centre = centre / len(verts)
        distanceFromCentre = 0.0

        for vert in verts:
            vecFromCentre = vert.co - centre
            vertDistanceFromCentre = vecFromCentre.length
            if vertDistanceFromCentre &gt; distanceFromCentre:
                distanceFromCentre = vertDistanceFromCentre
                vert1 = vert

        distance = 0.0
        for vert in verts:
            vec = vert.co - vert1.co
            vertsDistance = vec.length
            if vertsDistance &gt; distance:
                distance = vertsDistance
                vert2 = vert

        #return vert1, vert2, distance
        print ("vert:", vert1.co)
        return vert1.co, vert2.co

    # Return max vert distance NEW
    def max_vertDistance2(self, ob):

        verts = ob.data.vertices
        centre = Vector([0,0,0])
        for vert in verts:
            centre += vert.co

        centre = centre / len(verts)
        distanceFromCentre = 0.0

        for vert in verts:
            vecFromCentre = vert.co - centre
            vertDistanceFromCentre = vecFromCentre.length
            if vertDistanceFromCentre &gt; distanceFromCentre:
                distanceFromCentre = vertDistanceFromCentre
                vert1 = vert

        distance = 0.0
        for vert in verts:
            vec = vert.co - vert1.co
            vertsDistance = vec.length
            if vertsDistance &gt; distance:
                distance = vertsDistance
                vert2 = vert

        twoVerts = [vert1, vert2]

        newTwo = []
        wm = ob.matrix_world
        for v in twoVerts:
            world = wm * v.co
            #print(world)
            newTwo.append(world)

        #return vert1.co, vert2.co
        return newTwo

    # Calculate Raduis of sphere
    def get_radiusSphere(self, obj):
        return (obj.dimensions[0] / 2)

    # Return Materials of Geo
    def get_material(self, object):

        mat_diff = bpy.data.objects[object.name].active_material.diffuse_color
        mat_diff_int = bpy.data.objects[object.name].active_material.diffuse_intensity
        mat_spec = bpy.data.objects[object.name].active_material.specular_color
        mat_spec_int = bpy.data.objects[object.name].active_material.specular_intensity
        mat_amb = bpy.data.worlds["World"].ambient_color
        mat_amb_int = bpy.data.worlds["World"].custom.world_amount

        return mat_diff, mat_diff_int, mat_spec, mat_spec_int, mat_amb_int

    def diff_dimensions(self, dimensions):
        dimList = [round(dimensions.x, 3), round(dimensions.y, 3), round(dimensions.z, 3)]
        return [i for i in dimList if dimList.count(i) &gt; 1]

    # Return Material List
    def get_materialList(self):
        materialNames = []
        for material in bpy.data.materials:
            materialNames.append(material.name)
        return materialNames

    def app_materials(self):
        string = ""

        amb_r = bpy.context.scene.world.ambient_color.r
        amb_g = bpy.context.scene.world.ambient_color.g
        amb_b = bpy.context.scene.world.ambient_color.b
        ambient_int = bpy.context.scene.world.custom.world_amount        

        for i in bpy.data.materials:
            diff_r = bpy.data.materials[i.name].diffuse_color.r
            diff_g = bpy.data.materials[i.name].diffuse_color.g
            diff_b = bpy.data.materials[i.name].diffuse_color.b
            diff_int = bpy.data.materials[i.name].diffuse_intensity

            spec_r = bpy.data.materials[i.name].specular_color.r
            spec_b = bpy.data.materials[i.name].specular_color.b
            spec_g = bpy.data.materials[i.name].specular_color.g
            spec_int = bpy.data.materials[i.name].specular_intensity
            spec_hardness = bpy.data.materials[i.name].specular_hardness

            string += ("define material ") + i.name + " "

            # ambient
            string += str(amb_r * ambient_int)[:5] + " "
            string += str(amb_b * ambient_int)[:5] + " "
            string += str(amb_g * ambient_int)[:5] + " "

            # diffuse
            string += str(diff_r * diff_int)[:5] + " "
            string += str(diff_g * diff_int)[:5] + " "
            string += str(diff_b * diff_int)[:5] + " "

            # specular
            string += str(spec_r * spec_int)[:5] + " "
            string += str(spec_g * spec_int)[:5] + " "
            string += str(spec_b* spec_int)[:5] + " "
            string += str(spec_hardness)        

            string += "\n"

        return string

    # This is the only method called by blender, in this example
    # we use it to detect preview rendering and call the implementation
    # in another method.
    def render(self, scene):
        scale = scene.render.resolution_percentage / 100.0
        self.size_x = int(scene.render.resolution_x * scale)
        self.size_y = int(scene.render.resolution_y * scale)

        if scene.name == 'preview':
            self.render_preview(scene)
        else:
            self.render_scene(scene)

    # In this example, we fill the preview renders with a flat green color.
    def render_preview(self, scene):
        pixel_count = self.size_x * self.size_y

        # The framebuffer is defined as a list of pixels, each pixel
        # itself being a list of R,G,B,A values
        green_rect = [[0.0, 1.0, 0.0, 1.0]] * pixel_count

        # Here we write the pixel values to the RenderResult
        result = self.begin_result(0, 0, self.size_x, self.size_y)
        layer = result.layers[0]
        layer.rect = green_rect
        self.end_result(result)

    # In this example, we fill the full renders with a flat blue color.
    def render_scene(self, scene):
        pixel_count = self.size_x * self.size_y

        materialstring = self.app_materials()

        # collect geometry
        geo = self.get_allObjectsInSceneByType("MESH")
        geostring = ""
        transformstring = ""

        for item in geo:

            if (self.get_geoType(item) == "CUBE"):

                #print ("Location:", self.get_objectLocation(item))
                #print ("CENTER IS:", self.get_GeometryCenter(item))
                #print ("dimensions:", item.dimensions)
                #self.get_objectVerts(item)

                geostring += "define shape box "
                geostring += item.name + " "

                # first point
                geostring += str(self.max_vertDistance2(item)[0][0])[:5] + " "
                geostring += str(self.max_vertDistance2(item)[0][3])[:5] + " "
                geostring += str(self.max_vertDistance2(item)[0][4])[:5] + " "

                # second point
                geostring += str(self.max_vertDistance2(item)[1][0])[:5] + " "
                geostring += str(self.max_vertDistance2(item)[1][5])[:5] + " "
                geostring += str(self.max_vertDistance2(item)[1][6])[:5] + " "

                # material
                geostring += " " + bpy.data.objects[item.name].active_material.name
                geostring += "\n"

            else:

                geostring += "define shape sphere "               
                geostring += item.name + " "

                # center
                geostring += str(self.get_objectLocation(item)[0])[:5] + " "
                geostring += str(self.get_objectLocation(item)[2])[:5] + " "
                geostring += str(self.get_objectLocation(item)[1])[:5] + " "

                # radius
                geostring += str(self.get_radiusSphere(item))[:5]

                geostring += " " + bpy.data.objects[item.name].active_material.name
                geostring += "\n"

                # check for transformation
                dims = bpy.data.objects[item.name].dimensions                
                #print (round(dims.x, 3), round(dims.y, 3), round(dims.z, 3))
                #print (self.diff_dimensions(dims))

                if len(self.diff_dimensions(dims)) &lt; 3:
                    #print ("Transformation found!", item.name)
                    scle = bpy.data.objects[item.name].scale
                    transformstring += "transform "
                    transformstring += item.name + " scale " + str(round(scle.x,3)) + " " + str(round(scle.z,3)) + " " + str(round(scle.y,3)) + "\n" 
                    transformstring += "transform " + item.name + " translate 0 0 0\n"      
                '''
                print (scene.custom.app_path)
                print (scene.custom.scene_name)
                print (bpy.data.worlds["World"].ambient_color)
                print (bpy.context.scene.world.ambient_color)
                print (self.get_materialList())
                '''

        # collect lamps
        lamps = self.get_allObjectsInSceneByType("LAMP")
        lampstring = ""

        amb_r = bpy.context.scene.world.ambient_color.r
        amb_g = bpy.context.scene.world.ambient_color.g
        amb_b = bpy.context.scene.world.ambient_color.b

        for i in lamps:
            lampstring += "define light " + i.name + " "

            # position
            lampstring += str(self.get_objectLocation(i)[0])[:5] + " "
            lampstring += str(self.get_objectLocation(i)[2])[:5] + " "
            lampstring += str(self.get_objectLocation(i)[1])[:5] + " "

            # light ambient
            lampstring += str(amb_r)[:5] + " "
            lampstring += str(amb_g)[:5] + " "
            lampstring += str(amb_b)[:5] + " "

            # light diffuse
            lamp_energy = bpy.data.lamps[i.name].energy
            lampstring += str(bpy.data.lamps[i.name].color[0] * lamp_energy)[:5] + " "
            lampstring += str(bpy.data.lamps[i.name].color[1] * lamp_energy)[:5] + " "
            lampstring += str(bpy.data.lamps[i.name].color[2] * lamp_energy)[:5] + " "

            lampstring += "\n"

            #print ("Lamp energy:", bpy.data.lamps[i.name].energy)
            #print ("Lamp color:", bpy.data.lamps[i.name].color)
            #print ("Lamp location:", self.get_objectLocation(i))

        # get active camera

        obj_camera = bpy.context.scene.camera
        cameraName = obj_camera.name
        camerastring = "define camera " + cameraName + " "
        camerastring += str(bpy.data.cameras[cameraName].lens)[:5] + " "
        #camerastring += "35" + " "
        camerastring += str(self.get_objectLocation(obj_camera)[0])[:5] + " "
        camerastring += str(self.get_objectLocation(obj_camera)[2])[:5] + " "
        camerastring += str(self.get_objectLocation(obj_camera)[1])[:5] + " "

        # calculate up and direction vector
        cam = bpy.data.objects[obj_camera.name]
        #up = cam.matrix_world * Vector((0.0, 1.0, 0.0))
        #up = cam.matrix_world.to_3x3() * Vector((0.0, 1.0, 0.0))

        up = cam.matrix_world.to_quaternion() * Vector((0.0, 1.0, 0.0))
        #up = Vector((0.0, 1.0, 0.0))
        print ("UPVECTOR:", up)

        #cam_direction = cam.matrix_world * Vector((0.0, 0.0, -1.0))
        #cam_direction = cam.matrix_world.to_3x3() * Vector((0.0, 0.0, -1.0))

        cam_direction = cam.matrix_world.to_quaternion() * Vector((0.0, -1.0, -1.0))

        #cam_direction = Vector((0.0, 0.0, -1.0))
        #cam_direction.normalize()
        #up.normalize()

        camerastring += str(cam_direction[0])[:5] + " "
        camerastring += str(cam_direction[1])[:5] + " "
        camerastring += str(cam_direction[2])[:5] + " "

        camerastring += str(up[0])[:5] + " "
        camerastring += str(up[1])[:5] + " "
        camerastring += str(up[2])[:5] + " "

        camerastring += "\n"

        #camerastring = "define camera auge 60.0 1.0 1.0 3 0 -0.1 -1.0 0 1 0\n"

        # background color

        bgColor = bpy.data.worlds["World"].ambient_color
        bgColorstring = "define background-color " + str(bgColor[0]) + " " + str(bgColor[1]) + " " + str(bgColor[2]) + "\n"


        # ------------------------------------------------------------------------
        # render settings
        # ------------------------------------------------------------------------

        renderer = bpy.path.abspath(scene.custom.app_path)
        frameNumber = bpy.data.scenes["Scene"].frame_current

        scenename = scene.custom.scene_name        
        scale = scene.render.resolution_percentage / 100.0
        size_x = int(scene.render.resolution_x * scale)
        size_y = int(scene.render.resolution_y * scale)

        if not scenename:
            scenename = "AppScene"

        outfile_ppm = bpy.data.scenes["Scene"].render.filepath + scenename + "_" + str(self.formatNumbers(frameNumber)) + ".ppm"
        outfile_custom = bpy.data.scenes["Scene"].render.filepath + scenename + "_" + str(self.formatNumbers(frameNumber)) + ".sdf"

        rendersettingstring = "render " + obj_camera.name + " "
        rendersettingstring += outfile_ppm + " "
        rendersettingstring += str(size_x) + " "
        rendersettingstring += str(size_y) + " "
        rendersettingstring += "\n"

        file_content = bgColorstring + materialstring + geostring + transformstring + lampstring + camerastring + rendersettingstring

        # write custom file
        f = open(outfile_custom,'w')
        f.write(file_content)
        f.close()

        import signal
        import subprocess, time

        # for single image
        single_frame = subprocess.call([renderer, outfile_sdf])

        # for animation
        '''
        app_animation = subprocess.Popen([renderer, outfile_sdf])
        print ('app_animation\'s pid = ',app_animation.pid)
        time.sleep(170)
        app_animation.terminate()
        '''         
        print (materialstring + geostring + lampstring + camerastring + rendersettingstring)

        # The framebuffer is defined as a list of pixels, each pixel
        # itself being a list of R,G,B,A values
        blue_rect = [[0.0, 0.0, 1.0, 1.0]] * pixel_count

        # Here we write the pixel values to the RenderResult
        result = self.begin_result(0, 0, self.size_x, self.size_y)
        layer = result.layers[0]
        layer.rect = blue_rect
        self.end_result(result)


# Register the RenderEngine
bpy.utils.register_class(CustomRenderEngine)

# ======================================================================================
# UI
# ======================================================================================

from bpy.types import (AddonPreferences,
                       PropertyGroup,
                       Operator,
                       )
from bpy.props import (StringProperty,
                       BoolProperty,
                       IntProperty,
                       FloatProperty,
                       FloatVectorProperty,
                       EnumProperty,
                       PointerProperty,
                       )

# -----------------------------------------------------------------------------------
# Render properties
# example: https://github.com/meta-androcto/blenderpython/blob/master/scripts/archive/game_gamekit/ui.py
# -----------------------------------------------------------------------------------

from bl_ui import properties_render
properties_render.RENDER_PT_render.COMPAT_ENGINES.add('custom_renderer')
properties_render.RENDER_PT_dimensions.COMPAT_ENGINES.add('custom_renderer')
#properties_render.RENDER_PT_antialiasing.COMPAT_ENGINES.add('custom_renderer')
#properties_render.RENDER_PT_shading.COMPAT_ENGINES.add('custom_renderer')
properties_render.RENDER_PT_output.COMPAT_ENGINES.add('custom_renderer')
del properties_render

class RenderButtonsPanel():
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "render"
    # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here

    @classmethod
    def poll(cls, context):
        rd = context.scene.render
        return (rd.use_game_engine is False) and (rd.engine in cls.COMPAT_ENGINES)

class RenderCustomSettingsScene(PropertyGroup):

    deletefiles_enable = BoolProperty(
            name="Delete files",
            description="Delete files after rendering.",
            default=True)
    scene_name = StringProperty(
            name="Scene Name",
            description="Name of sdf scene to create.",
            maxlen=1024)
    app_path = StringProperty(
            name="Export scene path",
            # description="Path to directory where the exported scene is created"
            description="Path to Custom Engine",
            maxlen=1024, subtype="FILE_PATH")

class RENDER_PT_custom_export_settings(RenderButtonsPanel, bpy.types.Panel):
    bl_label = "Render Connection"
    COMPAT_ENGINES = {'custom_renderer'}

    def draw_header(self, context):
        self.layout.label(icon='CONSOLE')
    def draw(self, context):
        layout = self.layout
        scene = context.scene

        row = layout.row()
        row.column().prop(scene.custom, "app_path", text="Path to App")
        row = layout.row()
        row.column().prop(scene.custom, "scene_name", text="Scene Name")
        #row = layout.row()
        #row.column().prop(scene.custom, "deletefiles_enable", text="Delete files after Rendering")

# -----------------------------------------------------------------------------------
# Material properties
# -----------------------------------------------------------------------------------

from bl_ui import properties_material
properties_material.MATERIAL_PT_context_material.COMPAT_ENGINES.add('custom_renderer')
properties_material.MATERIAL_PT_diffuse.COMPAT_ENGINES.add('custom_renderer')
#properties_material.MATERIAL_PT_preview.COMPAT_ENGINES.add('custom_renderer')
#properties_material.MATERIAL_PT_shading.COMPAT_ENGINES.add('custom_renderer')
#properties_material.MATERIAL_PT_shadow.COMPAT_ENGINES.add('custom_renderer')
properties_material.MATERIAL_PT_specular.COMPAT_ENGINES.add('custom_renderer')
#properties_material.MATERIAL_PT_transp.COMPAT_ENGINES.add('custom_renderer')
del properties_material

class MaterialButtonsPanel():
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "material"
    # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here

    @classmethod
    def poll(cls, context):
        mat = context.material
        rd = context.scene.render
        return mat and (rd.use_game_engine is False) and (rd.engine in cls.COMPAT_ENGINES)

class RenderCustomSettingsMaterial(PropertyGroup):

    test_enable = BoolProperty(
        name="Enable",
        description="test enabler",
        default=False)

    test_amount = FloatProperty(
        name="amount",
        description="test",
        min=0.0, max=1.0, soft_min=0.01, soft_max=1.0, default=0.25)

# -----------------------------------------------------------------------------------
# Camera properties
# -----------------------------------------------------------------------------------

from bl_ui import properties_data_camera
properties_data_camera.DATA_PT_lens.COMPAT_ENGINES.add('custom_renderer')
del properties_data_camera

# -----------------------------------------------------------------------------------
# Lamp properties
# -----------------------------------------------------------------------------------

from bl_ui import properties_data_lamp
properties_data_lamp.DATA_PT_lamp.COMPAT_ENGINES.add('custom_renderer')
properties_data_lamp.DATA_PT_preview.COMPAT_ENGINES.add('custom_renderer')
del properties_data_lamp

# -----------------------------------------------------------------------------------
# World properties
# -----------------------------------------------------------------------------------

from bl_ui import properties_world
class WorldButtonsPanel():
    bl_space_type = 'PROPERTIES'
    bl_region_type = 'WINDOW'
    bl_context = "world"
    # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here

    @classmethod
    def poll(cls, context):
        wld = context.world
        rd = context.scene.render
        return wld and (rd.use_game_engine is False) and (rd.engine in cls.COMPAT_ENGINES)

class RenderCustomSettingsWorld(PropertyGroup):        

    world_amount = FloatProperty(
        name="amount",
        description="test",
        min=0.0, max=1.0, soft_min=0.01, soft_max=1.0, default=0.25)

class WORLD_PT_world(WorldButtonsPanel, bpy.types.Panel):
    bl_label = "World"
    COMPAT_ENGINES = {'custom_renderer'}

    def draw(self, context):
        layout = self.layout
        wld = context.world

        row = layout.row()
        row.column().prop(wld, "ambient_color")
        #row = layout.row()
        #row.column().prop(wld, "world_amount")
        row = layout.row()
        row.column().prop(wld.custom, "world_amount", slider=True)

#bpy.utils.register_class(WORLD_PT_world)


# ======================================================================================
# Register
# ======================================================================================

def register():
    bpy.utils.register_module(__name__)
    bpy.types.Scene.custom = PointerProperty(type=RenderCustomSettingsScene)
    #bpy.types.Material.custom = PointerProperty(type=RenderCustomSettingsMaterial)
    bpy.types.World.custom = PointerProperty(type=RenderCustomSettingsWorld)

def unregister():
    bpy.utils.unregister_module(__name__)
    del bpy.types.Scene.custom
    del bpy.types.Material.custom
    del bpy.types.World.custom
    del bpy.types.Scene.custom

if __name__ == "__main__":
    register()


Note: The script was written a while ago, it is a bit messy but I hope you get the idea.



For a simpler approach you can also extend the render panel. Best practice is to take a look into the templates that are shipped with blender:



To define your custom file output you can create a custom file property like this:

app_path = StringProperty(
            name="Export files to:",
            description=""
            description="Path",
            maxlen=1024, subtype="DIR_PATH")


or use scn.render.filepath. For this case here you can find a working example: Is it possible to render only keyframes from Dope-sheet?