I tried to code something simple that executes reasonably fast even with 100% coverage. There are certainly faster algorithms than mine if you're guaranteed to have small coverage ratios or if the image doesn't need to conform to the coverage ratio precisely. If the coverage ratio doesn't need to be precise, you can just use your own algorithm without the check for the already occupied pixels. That would be pretty much the fastest possible algorithm, I think, assuming that you can live with the small theoretical possibility of a significant number of stars overlapping.
If you need to get precisely the right coverage ratio and only need to support low coverage ratios, you can use your own algorithm, but with a different data structure for checking for occupied pixels. You could, for example, create an array of 0s the size of the image (or use the image itself as the array) and mark an element as 1 when you fill a pixel. That way you could simply index the array to see if the pixel is occupied. As long as the the coverage ratio is low, that should work pretty well since the number of collisions would remain small.
Consider the attached Python script public domain. Use it as a template for other algorithms, print it out and use it for target practice or stick it to the wall and throw darts at it. Enjoy the freedom while it lasts.