For a game I am working on I would like to implement a scrolling starfield. All the game so far is being drawn from OpenGL primitives and I would like to continue this and gl_points seems appropriate.
I am using pyglet (python) and know I could achieve this storing the positions of a whole bunch or points updating them and moving them manually but I was hoping there was a neater alternative.
EDIT:
In answer to Ian Mallett
I guess what I am trying to ask is if I generate a bunch of points, is there some way I can blit these onto some kind of surface or buffer and scroll this in the background.
Also as for what kind of star-field all I am trying to generate at this stage all I am trying for a simple single layer for a top down game, pretty much how you would have in asteroids
Can you clarify what sort of starfield?  2D scrolling (for a side or top scrolling game, maybe with different layers) or 3D (like really flying through a starfield in an impossibly fast spaceship)?
In the former, a texture (or layers of textures blended additively) is probably the cleanest and fastest approach.  [EDIT: Textures are by far the best approach, but if you really don't want to use textures, you can do the following, which is the next best thing:

Make a static VBO or display list of points that is maybe six times as large as it needs to be in the direction of scroll (e.g. if you're running 800x600 screen and you're scrolling horizontally, generate points on a 4800x600 grid).
Draw these points twice, offset by the width and the scrolling variable.  E.g., let x be your scrolling variable (it starts at 0, then is incremented until it reaches 4800 (the width of your points), and then wraps back around and restarts at 0).  Each frame, draw your points with a glTranslatef(x,0,0).  Then draw them again with a glTranslatef(x+4800,0,0).
In this way your points will scroll past seemingly continuously.  The constant (I chose six, above) doesn't really matter to the algorithm.  Larger values will have fewer repeats but slower performance.
You can also try doing all of the above several times with different scrolling constants to give the illusion of depth (with multiple layers).

]
In the latter, there are a bunch of clever algorithms I can think of, but I'd suggest just using the raw points (point sprites if you're feeling fancy); GPUs can handle this if you put them in a static VBO or display list.  If your points are small, you can probably throw a few thousand up at a time without any noticeable performance hit.
Scrolling starfield with gl_points in pyglet