Fibonacci point on a sphere
Scripting solution.

The parametric equations and code can be found here http://blog.marmakoide.org/?p=1

Used the points generated to create a point cloud mesh with vert normals pointing out, and a dupli vert object to display.

I couldn't work out the vert order to skin this properly, it  appears to follow a fibonacci like sequence with the vert order.


Here a 512 point with a cone and plane dupli, and a 32 pointer with a cube dupli.

import numpy
n = 512
golden_angle = numpy.pi * (3 - numpy.sqrt(5))
theta = golden_angle * numpy.arange(n)
z = numpy.linspace(1 - 1.0 / n, 1.0 / n - 1, n)
#z = numpy.zeros(n)
radius = numpy.sqrt(1 - z * z)

points = numpy.zeros((n, 3))
points[:,0] = radius * numpy.cos(theta)
points[:,1] = radius * numpy.sin(theta)
points[:,2] = z

import bpy
import bmesh
from math import radians
context = bpy.context
scene = context.scene

bm = bmesh.new()

meshdata = bpy.data.meshes.new("goldie")
verts = [bm.verts.new(p) for p in points]
"make vert normals point out"
for v in verts:
    v.normal = -v.co.normalized()
#bmesh.ops.convex_hull(bm, input=verts)
bm.to_mesh(meshdata)
goldie = bpy.data.objects.new("goldie", meshdata)   
scene.objects.link(goldie)
scene.objects.active = goldie
goldie.select = True
#make a dupe
bpy.ops.mesh.primitive_cone_add(location=(0,0,0))
plane = scene.objects.active
#plane.hide = True
plane.scale *= 32 / n
plane.rotation_euler = (radians(90), 0, 0)
bpy.ops.object.transform_apply(scale=True, rotation=True)
plane.parent = goldie
goldie.dupli_type = 'VERTS'
goldie.use_dupli_vertices_rotation = True


From a previous Loxodrome post

The vert order makes it easier to skin.  Change values for spirals, revs and ang to create differing meshes.   


Skinned loxodromes using varying parameters.

import bpy

from mathutils import Vector
from math import radians, sin, cos, tan, sqrt, floor

context = bpy.context

def loxodrome_points(spirals, revs, angle_step=10):
    a = 1 / spirals
    degs = floor(360 * revs / 2)
    segs = [radians(d) for d in range(-degs, degs, angle_step)]
    points = []
    for t in segs:
        den = sqrt(1 + a * a * t * t)
        x = cos(t) / den
        y = sin(t) / den
        z = - a * t / den
        l = Vector((x, y, z))
        points.append(l)     
    return points

ang = 20
spirals = 16
revs = 100
points = loxodrome_points(spirals, revs, angle_step=ang)
# quick n dirty
lazy = 360 // ang

import bmesh
bm = bmesh.new()

loxodata = bpy.data.meshes.new("loxo")
verts = [bm.verts.new(p) for p in points]
faces = [[i, i+1, i+lazy, i+lazy-1] for i in range(len(points)-lazy-1)]
for f in faces:
    bm.faces.new([verts[i] for i in f])
bm.to_mesh(loxodata)
loxodrome = bpy.data.objects.new("Loxodrome", loxodata)    
context.scene.objects.link(loxodrome)